default attribute of 
  indexA (rs1, rs2) is 
    (/\#n where #32 divides #n. 
      <RTLOP add> #n 
        (FETCH_METHOD #n (AGG_METHOD #32 #n ($r rs1))
        , FETCH_METHOD #n (AGG_METHOD #32 #n ($r rs2))
        )) : (\/ #n where #32 divides #n . #n bits)

default attribute of 
  dispA (rs1, simm13) is 
    (/\#n where #32 divides #n. 
      <RTLOP add> #n 
        (FETCH_METHOD #n (AGG_METHOD #32 #n ($r rs1))
        , <RTLOP sx> #13 #n simm13
        )) : (\/ #n where #32 divides #n . #n bits)

default attribute of rmode rs2 is $r rs2 : #32 cell

default attribute of 
  imode simm13 is (/\#n. <RTLOP sx> #13 #n simm13) : (\/ #n . #n bits)

default attribute of 
  ldsb (address, rd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($r rd)
      , <RTLOP sx> #8 #32 (FETCH_METHOD #8 (AGG_METHOD #8 #8 ($m address)))
      ) : rtl

default attribute of 
  ldsh (address, rd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($r rd)
      , <RTLOP sx> #32 #32 (FETCH_METHOD #32 (AGG_METHOD #8 #32 ($m address)))
      ) : rtl

default attribute of 
  ldub (address, rd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($r rd)
      , <RTLOP zx> #8 #32 (FETCH_METHOD #8 (AGG_METHOD #8 #8 ($m address)))
      ) : rtl

default attribute of 
  lduh (address, rd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($r rd)
      , <RTLOP zx> #32 #32 (FETCH_METHOD #32 (AGG_METHOD #8 #32 ($m address)))
      ) : rtl

default attribute of 
  ld (address, rd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($r rd)
      , FETCH_METHOD #32 (AGG_METHOD #8 #32 ($m address))
      ) : rtl

default attribute of 
  ldd (address, rd) is 
    STORE_METHOD #64 
      (AGG_METHOD #32 #64 ($r rd)
      , FETCH_METHOD #64 (AGG_METHOD #8 #64 ($m address))
      ) : rtl

default attribute of 
  sth (rd, address) is 
    STORE_METHOD #16 
      (AGG_METHOD #8 #16 ($m address)
      , 16-bits-at #ungeneralized-12 #32 
        (0 #ungeneralized-12, FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rd)))
      ) : rtl

default attribute of 
  stb (rd, address) is 
    STORE_METHOD #8 
      (AGG_METHOD #8 #8 ($m address)
      , 8-bits-at #ungeneralized-13 #32 
        (0 #ungeneralized-13, FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rd)))
      ) : rtl

default attribute of 
  st (rd, address) is 
    STORE_METHOD #32 
      (AGG_METHOD #8 #32 ($m address)
      , FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rd))
      ) : rtl

default attribute of 
  std (rd, address) is 
    STORE_METHOD #64 
      (AGG_METHOD #8 #64 ($m address)
      , FETCH_METHOD #64 (AGG_METHOD #32 #64 ($r rd))
      ) : rtl

default attribute of 
  ldstub (address, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP zx> #8 #32 (FETCH_METHOD #8 (AGG_METHOD #8 #8 ($m address)))
        )
      , STORE_METHOD #8 (AGG_METHOD #8 #8 ($m address), 255 #8)
      ) : rtl

default attribute of 
  swap (address, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , FETCH_METHOD #32 (AGG_METHOD #8 #32 ($m address))
        )
      , STORE_METHOD #32 
        (AGG_METHOD #8 #32 ($m address)
        , FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rd))
        )
      ) : rtl

default attribute of 
  save (rs1, reg_or_imm, rd) is 
    ; 
      (; 
        (; 
          (; 
            (; 
              (--> 
                (<RTLOP ne> #5 (rd, <RTLOP add> #5 (0, 24 #5))
                , STORE_METHOD #32 
                  (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (0, 24 #5)))
                  , FETCH_METHOD #32 
                    (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (0, 8 #5))))
                  )
                )
              , ; 
                (--> 
                  (<RTLOP ne> #5 (rd, <RTLOP add> #5 (1, 24 #5))
                  , STORE_METHOD #32 
                    (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (1, 24 #5)))
                    , FETCH_METHOD #32 
                      (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (1, 8 #5))))
                    )
                  )
                , ; 
                  (--> 
                    (<RTLOP ne> #5 (rd, <RTLOP add> #5 (2, 24 #5))
                    , STORE_METHOD #32 
                      (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (2, 24 #5)))
                      , FETCH_METHOD #32 
                        (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (2, 8 #5))))
                      )
                    )
                  , ; 
                    (--> 
                      (<RTLOP ne> #5 (rd, <RTLOP add> #5 (3, 24 #5))
                      , STORE_METHOD #32 
                        (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (3, 24 #5)))
                        , FETCH_METHOD #32 
                          (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (3, 8 #5))))
                        )
                      )
                    , ; 
                      (--> 
                        (<RTLOP ne> #5 (rd, <RTLOP add> #5 (4, 24 #5))
                        , STORE_METHOD #32 
                          (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (4, 24 #5)))
                          , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                              ($r (<RTLOP add> #5 (4, 8 #5))))
                          )
                        )
                      , ; 
                        (--> 
                          (<RTLOP ne> #5 (rd, <RTLOP add> #5 (5, 24 #5))
                          , STORE_METHOD #32 
                            (AGG_METHOD #32 #32 
                              ($r (<RTLOP add> #5 (5, 24 #5)))
                            , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                                ($r (<RTLOP add> #5 (5, 8 #5))))
                            )
                          )
                        , ; 
                          (--> 
                            (<RTLOP ne> #5 (rd, <RTLOP add> #5 (6, 24 #5))
                            , STORE_METHOD #32 
                              (AGG_METHOD #32 #32 
                                ($r (<RTLOP add> #5 (6, 24 #5)))
                              , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                                  ($r (<RTLOP add> #5 (6, 8 #5))))
                              )
                            )
                          , ; 
                            (--> 
                              (<RTLOP ne> #5 (rd, <RTLOP add> #5 (7, 24 #5))
                              , STORE_METHOD #32 
                                (AGG_METHOD #32 #32 
                                  ($r (<RTLOP add> #5 (7, 24 #5)))
                                , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                                    ($r (<RTLOP add> #5 (7, 8 #5))))
                                )
                              )
                            , SKIP
                            )
                          )
                        )
                      )
                    )
                  )
                )
              )
            , ; 
              (STORE_METHOD #32 
                (AGG-ID #32 ($w (<RTLOP add> #32 
                      (<RTLOP add> #32 
                        (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1))), 8 #32)
                      , <RTLOP zx> #5 #32 0
                      )))
                , FETCH_METHOD #32 
                  (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (0, 16 #5))))
                )
              , ; 
                (STORE_METHOD #32 
                  (AGG-ID #32 ($w (<RTLOP add> #32 
                        (<RTLOP add> #32 
                          (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1))), 8 #32)
                        , <RTLOP zx> #5 #32 1
                        )))
                  , FETCH_METHOD #32 
                    (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (1, 16 #5))))
                  )
                , ; 
                  (STORE_METHOD #32 
                    (AGG-ID #32 ($w (<RTLOP add> #32 
                          (<RTLOP add> #32 
                            (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1))), 8 #32)
                          , <RTLOP zx> #5 #32 2
                          )))
                    , FETCH_METHOD #32 
                      (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (2, 16 #5))))
                    )
                  , ; 
                    (STORE_METHOD #32 
                      (AGG-ID #32 ($w (<RTLOP add> #32 
                            (<RTLOP add> #32 
                              (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                              , 8 #32
                              )
                            , <RTLOP zx> #5 #32 3
                            )))
                      , FETCH_METHOD #32 
                        (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (3, 16 #5))))
                      )
                    , ; 
                      (STORE_METHOD #32 
                        (AGG-ID #32 ($w (<RTLOP add> #32 
                              (<RTLOP add> #32 
                                (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                , 8 #32
                                )
                              , <RTLOP zx> #5 #32 4
                              )))
                        , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                            ($r (<RTLOP add> #5 (4, 16 #5))))
                        )
                      , ; 
                        (STORE_METHOD #32 
                          (AGG-ID #32 ($w (<RTLOP add> #32 
                                (<RTLOP add> #32 
                                  (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                  , 8 #32
                                  )
                                , <RTLOP zx> #5 #32 5
                                )))
                          , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                              ($r (<RTLOP add> #5 (5, 16 #5))))
                          )
                        , ; 
                          (STORE_METHOD #32 
                            (AGG-ID #32 ($w (<RTLOP add> #32 
                                  (<RTLOP add> #32 
                                    (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                    , 8 #32
                                    )
                                  , <RTLOP zx> #5 #32 6
                                  )))
                            , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                                ($r (<RTLOP add> #5 (6, 16 #5))))
                            )
                          , ; 
                            (STORE_METHOD #32 
                              (AGG-ID #32 ($w (<RTLOP add> #32 
                                    (<RTLOP add> #32 
                                      (FETCH_METHOD #32 
                                        (AGG-ID #32 ($W (0 #1)))
                                      , 8 #32
                                      )
                                    , <RTLOP zx> #5 #32 7
                                    )))
                              , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                                  ($r (<RTLOP add> #5 (7, 16 #5))))
                              )
                            , SKIP
                            )
                          )
                        )
                      )
                    )
                  )
                )
              )
            )
          , ; 
            (STORE_METHOD #32 
              (AGG-ID #32 ($w (<RTLOP add> #32 
                    (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                    , <RTLOP zx> #5 #32 0
                    )))
              , FETCH_METHOD #32 
                (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (0, 24 #5))))
              )
            , ; 
              (STORE_METHOD #32 
                (AGG-ID #32 ($w (<RTLOP add> #32 
                      (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                      , <RTLOP zx> #5 #32 1
                      )))
                , FETCH_METHOD #32 
                  (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (1, 24 #5))))
                )
              , ; 
                (STORE_METHOD #32 
                  (AGG-ID #32 ($w (<RTLOP add> #32 
                        (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                        , <RTLOP zx> #5 #32 2
                        )))
                  , FETCH_METHOD #32 
                    (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (2, 24 #5))))
                  )
                , ; 
                  (STORE_METHOD #32 
                    (AGG-ID #32 ($w (<RTLOP add> #32 
                          (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                          , <RTLOP zx> #5 #32 3
                          )))
                    , FETCH_METHOD #32 
                      (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (3, 24 #5))))
                    )
                  , ; 
                    (STORE_METHOD #32 
                      (AGG-ID #32 ($w (<RTLOP add> #32 
                            (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                            , <RTLOP zx> #5 #32 4
                            )))
                      , FETCH_METHOD #32 
                        (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (4, 24 #5))))
                      )
                    , ; 
                      (STORE_METHOD #32 
                        (AGG-ID #32 ($w (<RTLOP add> #32 
                              (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                              , <RTLOP zx> #5 #32 5
                              )))
                        , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                            ($r (<RTLOP add> #5 (5, 24 #5))))
                        )
                      , ; 
                        (STORE_METHOD #32 
                          (AGG-ID #32 ($w (<RTLOP add> #32 
                                (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                , <RTLOP zx> #5 #32 6
                                )))
                          , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                              ($r (<RTLOP add> #5 (6, 24 #5))))
                          )
                        , ; 
                          (STORE_METHOD #32 
                            (AGG-ID #32 ($w (<RTLOP add> #32 
                                  (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                  , <RTLOP zx> #5 #32 7
                                  )))
                            , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                                ($r (<RTLOP add> #5 (7, 24 #5))))
                            )
                          , SKIP
                          )
                        )
                      )
                    )
                  )
                )
              )
            )
          )
        , STORE_METHOD #32 
          (AGG-ID #32 ($W (0 #1))
          , <RTLOP add> #32 
            (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1))), 16 #32)
          )
        )
      , STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP add> #32 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
        )
      ) : rtl

default attribute of 
  restore (rs1, reg_or_imm, rd) is 
    ; 
      (; 
        (; 
          (; 
            (; 
              (--> 
                (<RTLOP ne> #5 (rd, <RTLOP add> #5 (0, 8 #5))
                , STORE_METHOD #32 
                  (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (0, 8 #5)))
                  , FETCH_METHOD #32 
                    (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (0, 24 #5))))
                  )
                )
              , ; 
                (--> 
                  (<RTLOP ne> #5 (rd, <RTLOP add> #5 (1, 8 #5))
                  , STORE_METHOD #32 
                    (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (1, 8 #5)))
                    , FETCH_METHOD #32 
                      (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (1, 24 #5))))
                    )
                  )
                , ; 
                  (--> 
                    (<RTLOP ne> #5 (rd, <RTLOP add> #5 (2, 8 #5))
                    , STORE_METHOD #32 
                      (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (2, 8 #5)))
                      , FETCH_METHOD #32 
                        (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (2, 24 #5))))
                      )
                    )
                  , ; 
                    (--> 
                      (<RTLOP ne> #5 (rd, <RTLOP add> #5 (3, 8 #5))
                      , STORE_METHOD #32 
                        (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (3, 8 #5)))
                        , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                            ($r (<RTLOP add> #5 (3, 24 #5))))
                        )
                      )
                    , ; 
                      (--> 
                        (<RTLOP ne> #5 (rd, <RTLOP add> #5 (4, 8 #5))
                        , STORE_METHOD #32 
                          (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (4, 8 #5)))
                          , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                              ($r (<RTLOP add> #5 (4, 24 #5))))
                          )
                        )
                      , ; 
                        (--> 
                          (<RTLOP ne> #5 (rd, <RTLOP add> #5 (5, 8 #5))
                          , STORE_METHOD #32 
                            (AGG_METHOD #32 #32 
                              ($r (<RTLOP add> #5 (5, 8 #5)))
                            , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                                ($r (<RTLOP add> #5 (5, 24 #5))))
                            )
                          )
                        , ; 
                          (--> 
                            (<RTLOP ne> #5 (rd, <RTLOP add> #5 (6, 8 #5))
                            , STORE_METHOD #32 
                              (AGG_METHOD #32 #32 
                                ($r (<RTLOP add> #5 (6, 8 #5)))
                              , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                                  ($r (<RTLOP add> #5 (6, 24 #5))))
                              )
                            )
                          , ; 
                            (--> 
                              (<RTLOP ne> #5 (rd, <RTLOP add> #5 (7, 8 #5))
                              , STORE_METHOD #32 
                                (AGG_METHOD #32 #32 
                                  ($r (<RTLOP add> #5 (7, 8 #5)))
                                , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                                    ($r (<RTLOP add> #5 (7, 24 #5))))
                                )
                              )
                            , SKIP
                            )
                          )
                        )
                      )
                    )
                  )
                )
              )
            , ; 
              (--> 
                (<RTLOP ne> #5 (rd, <RTLOP add> #5 (0, 16 #5))
                , STORE_METHOD #32 
                  (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (0, 16 #5)))
                  , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                          (<RTLOP sub> #32 
                            (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1))), 8 #32)
                          , <RTLOP zx> #5 #32 0
                          ))))
                  )
                )
              , ; 
                (--> 
                  (<RTLOP ne> #5 (rd, <RTLOP add> #5 (1, 16 #5))
                  , STORE_METHOD #32 
                    (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (1, 16 #5)))
                    , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                            (<RTLOP sub> #32 
                              (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                              , 8 #32
                              )
                            , <RTLOP zx> #5 #32 1
                            ))))
                    )
                  )
                , ; 
                  (--> 
                    (<RTLOP ne> #5 (rd, <RTLOP add> #5 (2, 16 #5))
                    , STORE_METHOD #32 
                      (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (2, 16 #5)))
                      , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                              (<RTLOP sub> #32 
                                (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                , 8 #32
                                )
                              , <RTLOP zx> #5 #32 2
                              ))))
                      )
                    )
                  , ; 
                    (--> 
                      (<RTLOP ne> #5 (rd, <RTLOP add> #5 (3, 16 #5))
                      , STORE_METHOD #32 
                        (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (3, 16 #5)))
                        , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                                (<RTLOP sub> #32 
                                  (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                  , 8 #32
                                  )
                                , <RTLOP zx> #5 #32 3
                                ))))
                        )
                      )
                    , ; 
                      (--> 
                        (<RTLOP ne> #5 (rd, <RTLOP add> #5 (4, 16 #5))
                        , STORE_METHOD #32 
                          (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (4, 16 #5)))
                          , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                                  (<RTLOP sub> #32 
                                    (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                    , 8 #32
                                    )
                                  , <RTLOP zx> #5 #32 4
                                  ))))
                          )
                        )
                      , ; 
                        (--> 
                          (<RTLOP ne> #5 (rd, <RTLOP add> #5 (5, 16 #5))
                          , STORE_METHOD #32 
                            (AGG_METHOD #32 #32 
                              ($r (<RTLOP add> #5 (5, 16 #5)))
                            , FETCH_METHOD #32 
                              (AGG-ID #32 ($w (<RTLOP add> #32 
                                    (<RTLOP sub> #32 
                                      (FETCH_METHOD #32 
                                        (AGG-ID #32 ($W (0 #1)))
                                      , 8 #32
                                      )
                                    , <RTLOP zx> #5 #32 5
                                    ))))
                            )
                          )
                        , ; 
                          (--> 
                            (<RTLOP ne> #5 (rd, <RTLOP add> #5 (6, 16 #5))
                            , STORE_METHOD #32 
                              (AGG_METHOD #32 #32 
                                ($r (<RTLOP add> #5 (6, 16 #5)))
                              , FETCH_METHOD #32 
                                (AGG-ID #32 ($w (<RTLOP add> #32 
                                      (<RTLOP sub> #32 
                                        (FETCH_METHOD #32 
                                          (AGG-ID #32 ($W (0 #1)))
                                        , 8 #32
                                        )
                                      , <RTLOP zx> #5 #32 6
                                      ))))
                              )
                            )
                          , ; 
                            (--> 
                              (<RTLOP ne> #5 (rd, <RTLOP add> #5 (7, 16 #5))
                              , STORE_METHOD #32 
                                (AGG_METHOD #32 #32 
                                  ($r (<RTLOP add> #5 (7, 16 #5)))
                                , FETCH_METHOD #32 
                                  (AGG-ID #32 ($w (<RTLOP add> #32 
                                        (<RTLOP sub> #32 
                                          (FETCH_METHOD #32 
                                            (AGG-ID #32 ($W (0 #1)))
                                          , 8 #32
                                          )
                                        , <RTLOP zx> #5 #32 7
                                        ))))
                                )
                              )
                            , SKIP
                            )
                          )
                        )
                      )
                    )
                  )
                )
              )
            )
          , ; 
            (--> 
              (<RTLOP ne> #5 (rd, <RTLOP add> #5 (0, 24 #5))
              , STORE_METHOD #32 
                (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (0, 24 #5)))
                , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                        (<RTLOP sub> #32 
                          (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1))), 16 #32)
                        , <RTLOP zx> #5 #32 0
                        ))))
                )
              )
            , ; 
              (--> 
                (<RTLOP ne> #5 (rd, <RTLOP add> #5 (1, 24 #5))
                , STORE_METHOD #32 
                  (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (1, 24 #5)))
                  , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                          (<RTLOP sub> #32 
                            (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1))), 16 #32
                            )
                          , <RTLOP zx> #5 #32 1
                          ))))
                  )
                )
              , ; 
                (--> 
                  (<RTLOP ne> #5 (rd, <RTLOP add> #5 (2, 24 #5))
                  , STORE_METHOD #32 
                    (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (2, 24 #5)))
                    , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                            (<RTLOP sub> #32 
                              (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                              , 16 #32
                              )
                            , <RTLOP zx> #5 #32 2
                            ))))
                    )
                  )
                , ; 
                  (--> 
                    (<RTLOP ne> #5 (rd, <RTLOP add> #5 (3, 24 #5))
                    , STORE_METHOD #32 
                      (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (3, 24 #5)))
                      , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                              (<RTLOP sub> #32 
                                (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                , 16 #32
                                )
                              , <RTLOP zx> #5 #32 3
                              ))))
                      )
                    )
                  , ; 
                    (--> 
                      (<RTLOP ne> #5 (rd, <RTLOP add> #5 (4, 24 #5))
                      , STORE_METHOD #32 
                        (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (4, 24 #5)))
                        , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                                (<RTLOP sub> #32 
                                  (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                  , 16 #32
                                  )
                                , <RTLOP zx> #5 #32 4
                                ))))
                        )
                      )
                    , ; 
                      (--> 
                        (<RTLOP ne> #5 (rd, <RTLOP add> #5 (5, 24 #5))
                        , STORE_METHOD #32 
                          (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (5, 24 #5)))
                          , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                                  (<RTLOP sub> #32 
                                    (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                    , 16 #32
                                    )
                                  , <RTLOP zx> #5 #32 5
                                  ))))
                          )
                        )
                      , ; 
                        (--> 
                          (<RTLOP ne> #5 (rd, <RTLOP add> #5 (6, 24 #5))
                          , STORE_METHOD #32 
                            (AGG_METHOD #32 #32 
                              ($r (<RTLOP add> #5 (6, 24 #5)))
                            , FETCH_METHOD #32 
                              (AGG-ID #32 ($w (<RTLOP add> #32 
                                    (<RTLOP sub> #32 
                                      (FETCH_METHOD #32 
                                        (AGG-ID #32 ($W (0 #1)))
                                      , 16 #32
                                      )
                                    , <RTLOP zx> #5 #32 6
                                    ))))
                            )
                          )
                        , ; 
                          (--> 
                            (<RTLOP ne> #5 (rd, <RTLOP add> #5 (7, 24 #5))
                            , STORE_METHOD #32 
                              (AGG_METHOD #32 #32 
                                ($r (<RTLOP add> #5 (7, 24 #5)))
                              , FETCH_METHOD #32 
                                (AGG-ID #32 ($w (<RTLOP add> #32 
                                      (<RTLOP sub> #32 
                                        (FETCH_METHOD #32 
                                          (AGG-ID #32 ($W (0 #1)))
                                        , 16 #32
                                        )
                                      , <RTLOP zx> #5 #32 7
                                      ))))
                              )
                            )
                          , SKIP
                          )
                        )
                      )
                    )
                  )
                )
              )
            )
          )
        , STORE_METHOD #32 
          (AGG-ID #32 ($W (0 #1))
          , <RTLOP sub> #32 
            (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1))), 16 #32)
          )
        )
      , STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP add> #32 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
        )
      ) : rtl

default attribute of 
  andcc (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP and> #32 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
        )
      , STORE_METHOD #4 
        (4-bits-at-loc #ungeneralized-5 #32 
          (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
        , <RTLOP encapsulate_cc> 
          (<RTLOP and> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
          , 0 #1
          , 0 #1
          )
        )
      ) : rtl

default attribute of 
  and (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP and> #32 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
        )
      , SKIP
      ) : rtl

default attribute of 
  orcc (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP or> #32 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
        )
      , STORE_METHOD #4 
        (4-bits-at-loc #ungeneralized-5 #32 
          (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
        , <RTLOP encapsulate_cc> 
          (<RTLOP or> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
          , 0 #1
          , 0 #1
          )
        )
      ) : rtl

default attribute of 
  or (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP or> #32 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
        )
      , SKIP
      ) : rtl

default attribute of 
  xorcc (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP xor> #32 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
        )
      , STORE_METHOD #4 
        (4-bits-at-loc #ungeneralized-5 #32 
          (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
        , <RTLOP encapsulate_cc> 
          (<RTLOP xor> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
          , 0 #1
          , 0 #1
          )
        )
      ) : rtl

default attribute of 
  xor (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP xor> #32 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
        )
      , SKIP
      ) : rtl

default attribute of 
  andncc (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP and> #32 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
          , <RTLOP com> #32 reg_or_imm
          )
        )
      , STORE_METHOD #4 
        (4-bits-at-loc #ungeneralized-5 #32 
          (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
        , <RTLOP encapsulate_cc> 
          (<RTLOP and> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
            , <RTLOP com> #32 reg_or_imm
            )
          , 0 #1
          , 0 #1
          )
        )
      ) : rtl

default attribute of 
  andn (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP and> #32 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
          , <RTLOP com> #32 reg_or_imm
          )
        )
      , SKIP
      ) : rtl

default attribute of 
  orncc (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP or> #32 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
          , <RTLOP com> #32 reg_or_imm
          )
        )
      , STORE_METHOD #4 
        (4-bits-at-loc #ungeneralized-5 #32 
          (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
        , <RTLOP encapsulate_cc> 
          (<RTLOP or> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
            , <RTLOP com> #32 reg_or_imm
            )
          , 0 #1
          , 0 #1
          )
        )
      ) : rtl

default attribute of 
  orn (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP or> #32 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
          , <RTLOP com> #32 reg_or_imm
          )
        )
      , SKIP
      ) : rtl

default attribute of 
  xnorcc (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP xor> #32 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
          , <RTLOP com> #32 reg_or_imm
          )
        )
      , STORE_METHOD #4 
        (4-bits-at-loc #ungeneralized-5 #32 
          (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
        , <RTLOP encapsulate_cc> 
          (<RTLOP xor> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
            , <RTLOP com> #32 reg_or_imm
            )
          , 0 #1
          , 0 #1
          )
        )
      ) : rtl

default attribute of 
  xnor (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP xor> #32 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
          , <RTLOP com> #32 reg_or_imm
          )
        )
      , SKIP
      ) : rtl

default attribute of 
  add (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP add> #32 
          (<RTLOP add> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
          , <RTLOP zx> #1 #32 (0 #1)
          )
        )
      , --> 
        (FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP add> #32 
              (<RTLOP add> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
              , <RTLOP zx> #1 #32 (0 #1)
              )
            , <RTLOP bit> (<RTLOP add_overflows> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
                , reg_or_imm
                , 0 #1
                ))
            , <RTLOP carry> #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
              , reg_or_imm
              , 0 #1
              )
            )
          )
        )
      ) : rtl

default attribute of 
  addcc (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP add> #32 
          (<RTLOP add> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
          , <RTLOP zx> #1 #32 (0 #1)
          )
        )
      , --> 
        (NOT FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP add> #32 
              (<RTLOP add> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
              , <RTLOP zx> #1 #32 (0 #1)
              )
            , <RTLOP bit> (<RTLOP add_overflows> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
                , reg_or_imm
                , 0 #1
                ))
            , <RTLOP carry> #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
              , reg_or_imm
              , 0 #1
              )
            )
          )
        )
      ) : rtl

default attribute of 
  addx (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP add> #32 
          (<RTLOP add> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
          , <RTLOP zx> #1 #32 (<RTLOP carryBit> 
              (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
                  (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
          )
        )
      , --> 
        (FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP add> #32 
              (<RTLOP add> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
              , <RTLOP zx> #1 #32 (<RTLOP carryBit> 
                  (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
                      (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
              )
            , <RTLOP bit> (<RTLOP add_overflows> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
                , reg_or_imm
                , <RTLOP carryBit> 
                  (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
                      (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
                ))
            , <RTLOP carry> #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
              , reg_or_imm
              , <RTLOP carryBit> 
                (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
                    (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
              )
            )
          )
        )
      ) : rtl

default attribute of 
  addxcc (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP add> #32 
          (<RTLOP add> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
          , <RTLOP zx> #1 #32 (<RTLOP carryBit> 
              (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
                  (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
          )
        )
      , --> 
        (NOT FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP add> #32 
              (<RTLOP add> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
              , <RTLOP zx> #1 #32 (<RTLOP carryBit> 
                  (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
                      (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
              )
            , <RTLOP bit> (<RTLOP add_overflows> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
                , reg_or_imm
                , <RTLOP carryBit> 
                  (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
                      (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
                ))
            , <RTLOP carry> #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
              , reg_or_imm
              , <RTLOP carryBit> 
                (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
                    (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
              )
            )
          )
        )
      ) : rtl

default attribute of 
  umul (rs1, reg_or_imm, rd) is 
    ; 
      (; 
        (STORE_METHOD #32 
          (AGG-ID #32 ($i (3 #3))
          , 32-bits-at #ungeneralized-8 #32 
            (32 #ungeneralized-8
            , <RTLOP mulUn> #32 #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
            )
          )
        , STORE_METHOD #32 
          (AGG_METHOD #32 #32 ($r rd)
          , 32-bits-at #ungeneralized-9 #32 
            (0 #ungeneralized-9
            , <RTLOP mulUn> #32 #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
            )
          )
        )
      , --> 
        (FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP mulUn> #32 #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
            , <RTLOP undefined> #1
            , <RTLOP undefined> #1
            )
          )
        )
      ) : rtl

default attribute of 
  umulcc (rs1, reg_or_imm, rd) is 
    ; 
      (; 
        (STORE_METHOD #32 
          (AGG-ID #32 ($i (3 #3))
          , 32-bits-at #ungeneralized-8 #32 
            (32 #ungeneralized-8
            , <RTLOP mulUn> #32 #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
            )
          )
        , STORE_METHOD #32 
          (AGG_METHOD #32 #32 ($r rd)
          , 32-bits-at #ungeneralized-9 #32 
            (0 #ungeneralized-9
            , <RTLOP mulUn> #32 #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
            )
          )
        )
      , --> 
        (NOT FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP mulUn> #32 #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
            , <RTLOP undefined> #1
            , <RTLOP undefined> #1
            )
          )
        )
      ) : rtl

default attribute of 
  smul (rs1, reg_or_imm, rd) is 
    ; 
      (; 
        (STORE_METHOD #32 
          (AGG-ID #32 ($i (3 #3))
          , 32-bits-at #ungeneralized-8 #32 
            (32 #ungeneralized-8
            , <RTLOP mul> #32 #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
            )
          )
        , STORE_METHOD #32 
          (AGG_METHOD #32 #32 ($r rd)
          , 32-bits-at #ungeneralized-9 #32 
            (0 #ungeneralized-9
            , <RTLOP mul> #32 #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
            )
          )
        )
      , --> 
        (FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP mul> #32 #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
            , <RTLOP undefined> #1
            , <RTLOP undefined> #1
            )
          )
        )
      ) : rtl

default attribute of 
  smulcc (rs1, reg_or_imm, rd) is 
    ; 
      (; 
        (STORE_METHOD #32 
          (AGG-ID #32 ($i (3 #3))
          , 32-bits-at #ungeneralized-8 #32 
            (32 #ungeneralized-8
            , <RTLOP mul> #32 #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
            )
          )
        , STORE_METHOD #32 
          (AGG_METHOD #32 #32 ($r rd)
          , 32-bits-at #ungeneralized-9 #32 
            (0 #ungeneralized-9
            , <RTLOP mul> #32 #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
            )
          )
        )
      , --> 
        (NOT FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP mul> #32 #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
            , <RTLOP undefined> #1
            , <RTLOP undefined> #1
            )
          )
        )
      ) : rtl

default attribute of 
  ba (target, annul) is 
    --> 
      (<RTLOP A> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  bn (target, annul) is 
    --> 
      (<RTLOP N> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  bne (target, annul) is 
    --> 
      (<RTLOP NE> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  be (target, annul) is 
    --> 
      (<RTLOP E> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  bg (target, annul) is 
    --> 
      (<RTLOP G> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  ble (target, annul) is 
    --> 
      (<RTLOP LE> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  bge (target, annul) is 
    --> 
      (<RTLOP GE> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  bl (target, annul) is 
    --> 
      (<RTLOP L> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  bgu (target, annul) is 
    --> 
      (<RTLOP GU> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  bleu (target, annul) is 
    --> 
      (<RTLOP LEU> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  bcc (target, annul) is 
    --> 
      (<RTLOP CC> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  bcs (target, annul) is 
    --> 
      (<RTLOP CS> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  bpos (target, annul) is 
    --> 
      (<RTLOP POS> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  bneg (target, annul) is 
    --> 
      (<RTLOP NEG> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  bvc (target, annul) is 
    --> 
      (<RTLOP VC> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  bvs (target, annul) is 
    --> 
      (<RTLOP VS> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  call target is 
    ; 
      (STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      , STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (7 #5, 8 #5)))
        , FETCH_METHOD #32 (AGG-ID #32 ($i (4 #3)))
        )
      ) : rtl

default attribute of 
  jmpl (address, rd) is 
    ; 
      (STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), address)
      , STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd), FETCH_METHOD #32 (AGG-ID #32 ($i (4 #3)))
        )
      ) : rtl

default attribute of 
  ldf (address, fd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($f fd)
      , FETCH_METHOD #32 (AGG_METHOD #8 #32 ($m address))
      ) : rtl

default attribute of 
  lddf (address, fd) is 
    STORE_METHOD #64 
      (AGG_METHOD #32 #64 ($f fd)
      , FETCH_METHOD #64 (AGG_METHOD #8 #64 ($m address))
      ) : rtl

default attribute of 
  ldfsr address is 
    STORE_METHOD #32 
      (AGG-ID #32 ($F (0 #1))
      , FETCH_METHOD #32 (AGG_METHOD #8 #32 ($m address))
      ) : rtl

default attribute of 
  ldc (address, cd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($c cd)
      , FETCH_METHOD #32 (AGG_METHOD #8 #32 ($m address))
      ) : rtl

default attribute of 
  lddc (address, cd) is 
    STORE_METHOD #64 
      (AGG_METHOD #32 #64 ($c cd)
      , FETCH_METHOD #64 (AGG_METHOD #8 #64 ($m address))
      ) : rtl

default attribute of 
  ldcsr address is 
    STORE_METHOD #32 
      (AGG-ID #32 ($C (0 #1))
      , FETCH_METHOD #32 (AGG_METHOD #8 #32 ($m address))
      ) : rtl

default attribute of 
  stf (fd, address) is 
    STORE_METHOD #32 
      (AGG_METHOD #8 #32 ($m address)
      , FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fd))
      ) : rtl

default attribute of 
  stdf (fd, address) is 
    STORE_METHOD #64 
      (AGG_METHOD #8 #64 ($m address)
      , FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fd))
      ) : rtl

default attribute of 
  stfsr address is 
    STORE_METHOD #32 
      (AGG_METHOD #8 #32 ($m address)
      , FETCH_METHOD #32 (AGG-ID #32 ($F (0 #1)))
      ) : rtl

default attribute of 
  stc (cd, address) is 
    STORE_METHOD #32 
      (AGG_METHOD #8 #32 ($m address)
      , FETCH_METHOD #32 (AGG_METHOD #32 #32 ($c cd))
      ) : rtl

default attribute of 
  stdc (cd, address) is 
    STORE_METHOD #64 
      (AGG_METHOD #8 #64 ($m address)
      , FETCH_METHOD #64 (AGG_METHOD #32 #64 ($c cd))
      ) : rtl

default attribute of 
  stcsr address is 
    STORE_METHOD #32 
      (AGG_METHOD #8 #32 ($m address)
      , FETCH_METHOD #32 (AGG-ID #32 ($C (0 #1)))
      ) : rtl

default attribute of 
  ldnext (fd, address) is 
    STORE_METHOD #32 
      (32-bits-at-loc #ungeneralized-14 #64 
        (0 #ungeneralized-14, AGG_METHOD #32 #64 ($f fd))
      , FETCH_METHOD #32 (AGG_METHOD #8 #32 ($m address))
      ) : rtl

default attribute of 
  stnext (fd, address) is 
    STORE_METHOD #32 
      (AGG_METHOD #8 #32 ($m address)
      , 32-bits-at #ungeneralized-15 #64 
        (0 #ungeneralized-15, FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fd)))
      ) : rtl

default attribute of 
  sethi (imm22, rd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($r rd)
      , <RTLOP bitInsert> #ungeneralized-16 #32 #22 
        ({wide is 0 #32, lsb is 10 #ungeneralized-16}, imm22)
      ) : rtl

default attribute of 
  sll (rs1, reg_or_imm, rd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($r rd)
      , <RTLOP lshift> #5 #32 
        (32 #5
        , FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
        , 5-bits-at #ungeneralized-17 #32 (0 #ungeneralized-17, reg_or_imm)
        )
      ) : rtl

default attribute of 
  srl (rs1, reg_or_imm, rd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($r rd)
      , <RTLOP rshift> #5 #32 
        (32 #5
        , FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
        , 5-bits-at #ungeneralized-18 #32 (0 #ungeneralized-18, reg_or_imm)
        )
      ) : rtl

default attribute of 
  sra (rs1, reg_or_imm, rd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($r rd)
      , <RTLOP rshiftA> #5 #32 
        (32 #5
        , FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
        , 5-bits-at #ungeneralized-19 #32 (0 #ungeneralized-19, reg_or_imm)
        )
      ) : rtl

default attribute of 
  taddcc (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP add> #32 
          (<RTLOP add> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
          , <RTLOP zx> #1 #32 (0 #1)
          )
        )
      , --> 
        (NOT FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP add> #32 
              (<RTLOP add> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
              , <RTLOP zx> #1 #32 (0 #1)
              )
            , <RTLOP bit> (<RTLOP add_overflows> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
                , reg_or_imm
                , 0 #1
                ))
            , <RTLOP carry> #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
              , reg_or_imm
              , 0 #1
              )
            )
          )
        )
      ) : rtl

default attribute of 
  taddcctv (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP add> #32 
          (<RTLOP add> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
          , <RTLOP zx> #1 #32 (0 #1)
          )
        )
      , --> 
        (NOT FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP add> #32 
              (<RTLOP add> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
              , <RTLOP zx> #1 #32 (0 #1)
              )
            , <RTLOP bit> (<RTLOP add_overflows> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
                , reg_or_imm
                , 0 #1
                ))
            , <RTLOP carry> #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
              , reg_or_imm
              , 0 #1
              )
            )
          )
        )
      ) : rtl

default attribute of 
  sub (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP sub> #32 
          (<RTLOP sub> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
          , <RTLOP zx> #1 #32 (0 #1)
          )
        )
      , --> 
        (FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP sub> #32 
              (<RTLOP sub> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
              , <RTLOP zx> #1 #32 (0 #1)
              )
            , <RTLOP bit> (<RTLOP sub_overflows> 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
                , reg_or_imm
                , 0 #1
                ))
            , <RTLOP borrow> #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
              , reg_or_imm
              , 0 #1
              )
            )
          )
        )
      ) : rtl

default attribute of 
  subcc (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP sub> #32 
          (<RTLOP sub> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
          , <RTLOP zx> #1 #32 (0 #1)
          )
        )
      , --> 
        (NOT FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP sub> #32 
              (<RTLOP sub> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
              , <RTLOP zx> #1 #32 (0 #1)
              )
            , <RTLOP bit> (<RTLOP sub_overflows> 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
                , reg_or_imm
                , 0 #1
                ))
            , <RTLOP borrow> #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
              , reg_or_imm
              , 0 #1
              )
            )
          )
        )
      ) : rtl

default attribute of 
  subx (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP sub> #32 
          (<RTLOP sub> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
          , <RTLOP zx> #1 #32 (<RTLOP carryBit> 
              (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
                  (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
          )
        )
      , --> 
        (FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP sub> #32 
              (<RTLOP sub> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
              , <RTLOP zx> #1 #32 (<RTLOP carryBit> 
                  (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
                      (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
              )
            , <RTLOP bit> (<RTLOP sub_overflows> 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
                , reg_or_imm
                , <RTLOP carryBit> 
                  (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
                      (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
                ))
            , <RTLOP borrow> #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
              , reg_or_imm
              , <RTLOP carryBit> 
                (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
                    (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
              )
            )
          )
        )
      ) : rtl

default attribute of 
  subxcc (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP sub> #32 
          (<RTLOP sub> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
          , <RTLOP zx> #1 #32 (<RTLOP carryBit> 
              (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
                  (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
          )
        )
      , --> 
        (NOT FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP sub> #32 
              (<RTLOP sub> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
              , <RTLOP zx> #1 #32 (<RTLOP carryBit> 
                  (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
                      (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
              )
            , <RTLOP bit> (<RTLOP sub_overflows> 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
                , reg_or_imm
                , <RTLOP carryBit> 
                  (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
                      (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
                ))
            , <RTLOP borrow> #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
              , reg_or_imm
              , <RTLOP carryBit> 
                (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
                    (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
              )
            )
          )
        )
      ) : rtl

default attribute of 
  tsubcc (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP sub> #32 
          (<RTLOP sub> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
          , <RTLOP zx> #1 #32 (0 #1)
          )
        )
      , --> 
        (NOT FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP sub> #32 
              (<RTLOP sub> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
              , <RTLOP zx> #1 #32 (0 #1)
              )
            , <RTLOP bit> (<RTLOP sub_overflows> 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
                , reg_or_imm
                , 0 #1
                ))
            , <RTLOP borrow> #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
              , reg_or_imm
              , 0 #1
              )
            )
          )
        )
      ) : rtl

default attribute of 
  tsubcctv (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP sub> #32 
          (<RTLOP sub> #32 
            (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
          , <RTLOP zx> #1 #32 (0 #1)
          )
        )
      , --> 
        (NOT FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP sub> #32 
              (<RTLOP sub> #32 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
              , <RTLOP zx> #1 #32 (0 #1)
              )
            , <RTLOP bit> (<RTLOP sub_overflows> 
                (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
                , reg_or_imm
                , 0 #1
                ))
            , <RTLOP borrow> #32 
              (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1))
              , reg_or_imm
              , 0 #1
              )
            )
          )
        )
      ) : rtl

default attribute of 
  udiv (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP divRz> #64 #32 
          (<RTLOP bitInsert> #ungeneralized-10 #64 #32 
            (
            {wide is 
                <RTLOP zx> #32 #64 
                  (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)))
            , lsb is 32 #ungeneralized-10
            }
            , FETCH_METHOD #32 (AGG-ID #32 ($i (3 #3)))
            )
          , reg_or_imm
          )
        )
      , --> 
        (FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP divRz> #64 #32 
              (<RTLOP bitInsert> #ungeneralized-10 #64 #32 
                (
                {wide is 
                    <RTLOP zx> #32 #64 
                      (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)))
                , lsb is 32 #ungeneralized-10
                }
                , FETCH_METHOD #32 (AGG-ID #32 ($i (3 #3)))
                )
              , reg_or_imm
              )
            , <RTLOP sparc_sdiv_overflow> 
              (<RTLOP bitInsert> #ungeneralized-10 #64 #32 
                (
                {wide is 
                    <RTLOP zx> #32 #64 
                      (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)))
                , lsb is 32 #ungeneralized-10
                }
                , FETCH_METHOD #32 (AGG-ID #32 ($i (3 #3)))
                )
              , reg_or_imm
              )
            , 0 #1
            )
          )
        )
      ) : rtl

default attribute of 
  udivcc (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP divRz> #64 #32 
          (<RTLOP bitInsert> #ungeneralized-10 #64 #32 
            (
            {wide is 
                <RTLOP zx> #32 #64 
                  (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)))
            , lsb is 32 #ungeneralized-10
            }
            , FETCH_METHOD #32 (AGG-ID #32 ($i (3 #3)))
            )
          , reg_or_imm
          )
        )
      , --> 
        (NOT FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP divRz> #64 #32 
              (<RTLOP bitInsert> #ungeneralized-10 #64 #32 
                (
                {wide is 
                    <RTLOP zx> #32 #64 
                      (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)))
                , lsb is 32 #ungeneralized-10
                }
                , FETCH_METHOD #32 (AGG-ID #32 ($i (3 #3)))
                )
              , reg_or_imm
              )
            , <RTLOP sparc_sdiv_overflow> 
              (<RTLOP bitInsert> #ungeneralized-10 #64 #32 
                (
                {wide is 
                    <RTLOP zx> #32 #64 
                      (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)))
                , lsb is 32 #ungeneralized-10
                }
                , FETCH_METHOD #32 (AGG-ID #32 ($i (3 #3)))
                )
              , reg_or_imm
              )
            , 0 #1
            )
          )
        )
      ) : rtl

default attribute of 
  sdiv (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP divUn> #64 #32 
          (<RTLOP bitInsert> #ungeneralized-10 #64 #32 
            (
            {wide is 
                <RTLOP zx> #32 #64 
                  (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)))
            , lsb is 32 #ungeneralized-10
            }
            , FETCH_METHOD #32 (AGG-ID #32 ($i (3 #3)))
            )
          , reg_or_imm
          )
        )
      , --> 
        (FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP divUn> #64 #32 
              (<RTLOP bitInsert> #ungeneralized-10 #64 #32 
                (
                {wide is 
                    <RTLOP zx> #32 #64 
                      (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)))
                , lsb is 32 #ungeneralized-10
                }
                , FETCH_METHOD #32 (AGG-ID #32 ($i (3 #3)))
                )
              , reg_or_imm
              )
            , <RTLOP sparc_udiv_overflow> 
              (<RTLOP bitInsert> #ungeneralized-10 #64 #32 
                (
                {wide is 
                    <RTLOP zx> #32 #64 
                      (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)))
                , lsb is 32 #ungeneralized-10
                }
                , FETCH_METHOD #32 (AGG-ID #32 ($i (3 #3)))
                )
              , reg_or_imm
              )
            , 0 #1
            )
          )
        )
      ) : rtl

default attribute of 
  sdivcc (rs1, reg_or_imm, rd) is 
    ; 
      (STORE_METHOD #32 
        (AGG_METHOD #32 #32 ($r rd)
        , <RTLOP divUn> #64 #32 
          (<RTLOP bitInsert> #ungeneralized-10 #64 #32 
            (
            {wide is 
                <RTLOP zx> #32 #64 
                  (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)))
            , lsb is 32 #ungeneralized-10
            }
            , FETCH_METHOD #32 (AGG-ID #32 ($i (3 #3)))
            )
          , reg_or_imm
          )
        )
      , --> 
        (NOT FALSE
        , STORE_METHOD #4 
          (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))
          , <RTLOP encapsulate_cc> 
            (<RTLOP divUn> #64 #32 
              (<RTLOP bitInsert> #ungeneralized-10 #64 #32 
                (
                {wide is 
                    <RTLOP zx> #32 #64 
                      (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)))
                , lsb is 32 #ungeneralized-10
                }
                , FETCH_METHOD #32 (AGG-ID #32 ($i (3 #3)))
                )
              , reg_or_imm
              )
            , <RTLOP sparc_udiv_overflow> 
              (<RTLOP bitInsert> #ungeneralized-10 #64 #32 
                (
                {wide is 
                    <RTLOP zx> #32 #64 
                      (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)))
                , lsb is 32 #ungeneralized-10
                }
                , FETCH_METHOD #32 (AGG-ID #32 ($i (3 #3)))
                )
              , reg_or_imm
              )
            , 0 #1
            )
          )
        )
      ) : rtl

default attribute of 
  fba (target, annul) is 
    --> 
      (<RTLOP fba> (FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-7 #32 
            (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  fbn (target, annul) is 
    --> 
      (<RTLOP fbn> (FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-7 #32 
            (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  fbu (target, annul) is 
    --> 
      (<RTLOP fbu> (FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-7 #32 
            (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  fbg (target, annul) is 
    --> 
      (<RTLOP fbg> (FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-7 #32 
            (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  fbug (target, annul) is 
    --> 
      (<RTLOP fbug> (FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-7 #32 
            (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  fbl (target, annul) is 
    --> 
      (<RTLOP fbl> (FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-7 #32 
            (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  fbul (target, annul) is 
    --> 
      (<RTLOP fbul> (FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-7 #32 
            (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  fblg (target, annul) is 
    --> 
      (<RTLOP fblg> (FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-7 #32 
            (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  fbne (target, annul) is 
    --> 
      (<RTLOP fbne> (FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-7 #32 
            (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  fbe (target, annul) is 
    --> 
      (<RTLOP fbe> (FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-7 #32 
            (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  fbue (target, annul) is 
    --> 
      (<RTLOP fbue> (FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-7 #32 
            (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  fbge (target, annul) is 
    --> 
      (<RTLOP fbge> (FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-7 #32 
            (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  fbuge (target, annul) is 
    --> 
      (<RTLOP fbuge> (FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-7 #32 
            (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  fble (target, annul) is 
    --> 
      (<RTLOP fble> (FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-7 #32 
            (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  fbule (target, annul) is 
    --> 
      (<RTLOP fbule> (FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-7 #32 
            (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  fbo (target, annul) is 
    --> 
      (<RTLOP fbo> (FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-7 #32 
            (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))))
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), target)
      ) : rtl

default attribute of 
  rett address is 
    ; 
      (; 
        (; 
          (; 
            (; 
              (; 
                (; 
                  (STORE_METHOD #32 
                    (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (0, 8 #5)))
                    , FETCH_METHOD #32 
                      (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (0, 24 #5))))
                    )
                  , ; 
                    (STORE_METHOD #32 
                      (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (1, 8 #5)))
                      , FETCH_METHOD #32 
                        (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (1, 24 #5))))
                      )
                    , ; 
                      (STORE_METHOD #32 
                        (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (2, 8 #5)))
                        , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                            ($r (<RTLOP add> #5 (2, 24 #5))))
                        )
                      , ; 
                        (STORE_METHOD #32 
                          (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (3, 8 #5)))
                          , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                              ($r (<RTLOP add> #5 (3, 24 #5))))
                          )
                        , ; 
                          (STORE_METHOD #32 
                            (AGG_METHOD #32 #32 
                              ($r (<RTLOP add> #5 (4, 8 #5)))
                            , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                                ($r (<RTLOP add> #5 (4, 24 #5))))
                            )
                          , ; 
                            (STORE_METHOD #32 
                              (AGG_METHOD #32 #32 
                                ($r (<RTLOP add> #5 (5, 8 #5)))
                              , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                                  ($r (<RTLOP add> #5 (5, 24 #5))))
                              )
                            , ; 
                              (STORE_METHOD #32 
                                (AGG_METHOD #32 #32 
                                  ($r (<RTLOP add> #5 (6, 8 #5)))
                                , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                                    ($r (<RTLOP add> #5 (6, 24 #5))))
                                )
                              , ; 
                                (STORE_METHOD #32 
                                  (AGG_METHOD #32 #32 
                                    ($r (<RTLOP add> #5 (7, 8 #5)))
                                  , FETCH_METHOD #32 (AGG_METHOD #32 #32 
                                      ($r (<RTLOP add> #5 (7, 24 #5))))
                                  )
                                , SKIP
                                )
                              )
                            )
                          )
                        )
                      )
                    )
                  )
                , ; 
                  (STORE_METHOD #32 
                    (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (0, 16 #5)))
                    , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                            (<RTLOP sub> #32 
                              (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                              , 8 #32
                              )
                            , <RTLOP zx> #5 #32 0
                            ))))
                    )
                  , ; 
                    (STORE_METHOD #32 
                      (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (1, 16 #5)))
                      , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                              (<RTLOP sub> #32 
                                (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                , 8 #32
                                )
                              , <RTLOP zx> #5 #32 1
                              ))))
                      )
                    , ; 
                      (STORE_METHOD #32 
                        (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (2, 16 #5)))
                        , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                                (<RTLOP sub> #32 
                                  (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                  , 8 #32
                                  )
                                , <RTLOP zx> #5 #32 2
                                ))))
                        )
                      , ; 
                        (STORE_METHOD #32 
                          (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (3, 16 #5)))
                          , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                                  (<RTLOP sub> #32 
                                    (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                    , 8 #32
                                    )
                                  , <RTLOP zx> #5 #32 3
                                  ))))
                          )
                        , ; 
                          (STORE_METHOD #32 
                            (AGG_METHOD #32 #32 
                              ($r (<RTLOP add> #5 (4, 16 #5)))
                            , FETCH_METHOD #32 
                              (AGG-ID #32 ($w (<RTLOP add> #32 
                                    (<RTLOP sub> #32 
                                      (FETCH_METHOD #32 
                                        (AGG-ID #32 ($W (0 #1)))
                                      , 8 #32
                                      )
                                    , <RTLOP zx> #5 #32 4
                                    ))))
                            )
                          , ; 
                            (STORE_METHOD #32 
                              (AGG_METHOD #32 #32 
                                ($r (<RTLOP add> #5 (5, 16 #5)))
                              , FETCH_METHOD #32 
                                (AGG-ID #32 ($w (<RTLOP add> #32 
                                      (<RTLOP sub> #32 
                                        (FETCH_METHOD #32 
                                          (AGG-ID #32 ($W (0 #1)))
                                        , 8 #32
                                        )
                                      , <RTLOP zx> #5 #32 5
                                      ))))
                              )
                            , ; 
                              (STORE_METHOD #32 
                                (AGG_METHOD #32 #32 
                                  ($r (<RTLOP add> #5 (6, 16 #5)))
                                , FETCH_METHOD #32 
                                  (AGG-ID #32 ($w (<RTLOP add> #32 
                                        (<RTLOP sub> #32 
                                          (FETCH_METHOD #32 
                                            (AGG-ID #32 ($W (0 #1)))
                                          , 8 #32
                                          )
                                        , <RTLOP zx> #5 #32 6
                                        ))))
                                )
                              , ; 
                                (STORE_METHOD #32 
                                  (AGG_METHOD #32 #32 
                                    ($r (<RTLOP add> #5 (7, 16 #5)))
                                  , FETCH_METHOD #32 
                                    (AGG-ID #32 ($w (<RTLOP add> #32 
                                          (<RTLOP sub> #32 
                                            (FETCH_METHOD #32 
                                              (AGG-ID #32 ($W (0 #1)))
                                            , 8 #32
                                            )
                                          , <RTLOP zx> #5 #32 7
                                          ))))
                                  )
                                , SKIP
                                )
                              )
                            )
                          )
                        )
                      )
                    )
                  )
                )
              , ; 
                (STORE_METHOD #32 
                  (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (0, 24 #5)))
                  , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                          (<RTLOP sub> #32 
                            (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1))), 16 #32
                            )
                          , <RTLOP zx> #5 #32 0
                          ))))
                  )
                , ; 
                  (STORE_METHOD #32 
                    (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (1, 24 #5)))
                    , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                            (<RTLOP sub> #32 
                              (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                              , 16 #32
                              )
                            , <RTLOP zx> #5 #32 1
                            ))))
                    )
                  , ; 
                    (STORE_METHOD #32 
                      (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (2, 24 #5)))
                      , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                              (<RTLOP sub> #32 
                                (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                , 16 #32
                                )
                              , <RTLOP zx> #5 #32 2
                              ))))
                      )
                    , ; 
                      (STORE_METHOD #32 
                        (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (3, 24 #5)))
                        , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                                (<RTLOP sub> #32 
                                  (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                  , 16 #32
                                  )
                                , <RTLOP zx> #5 #32 3
                                ))))
                        )
                      , ; 
                        (STORE_METHOD #32 
                          (AGG_METHOD #32 #32 ($r (<RTLOP add> #5 (4, 24 #5)))
                          , FETCH_METHOD #32 (AGG-ID #32 ($w (<RTLOP add> #32 
                                  (<RTLOP sub> #32 
                                    (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1)))
                                    , 16 #32
                                    )
                                  , <RTLOP zx> #5 #32 4
                                  ))))
                          )
                        , ; 
                          (STORE_METHOD #32 
                            (AGG_METHOD #32 #32 
                              ($r (<RTLOP add> #5 (5, 24 #5)))
                            , FETCH_METHOD #32 
                              (AGG-ID #32 ($w (<RTLOP add> #32 
                                    (<RTLOP sub> #32 
                                      (FETCH_METHOD #32 
                                        (AGG-ID #32 ($W (0 #1)))
                                      , 16 #32
                                      )
                                    , <RTLOP zx> #5 #32 5
                                    ))))
                            )
                          , ; 
                            (STORE_METHOD #32 
                              (AGG_METHOD #32 #32 
                                ($r (<RTLOP add> #5 (6, 24 #5)))
                              , FETCH_METHOD #32 
                                (AGG-ID #32 ($w (<RTLOP add> #32 
                                      (<RTLOP sub> #32 
                                        (FETCH_METHOD #32 
                                          (AGG-ID #32 ($W (0 #1)))
                                        , 16 #32
                                        )
                                      , <RTLOP zx> #5 #32 6
                                      ))))
                              )
                            , ; 
                              (STORE_METHOD #32 
                                (AGG_METHOD #32 #32 
                                  ($r (<RTLOP add> #5 (7, 24 #5)))
                                , FETCH_METHOD #32 
                                  (AGG-ID #32 ($w (<RTLOP add> #32 
                                        (<RTLOP sub> #32 
                                          (FETCH_METHOD #32 
                                            (AGG-ID #32 ($W (0 #1)))
                                          , 16 #32
                                          )
                                        , <RTLOP zx> #5 #32 7
                                        ))))
                                )
                              , SKIP
                              )
                            )
                          )
                        )
                      )
                    )
                  )
                )
              )
            , STORE_METHOD #32 
              (AGG-ID #32 ($W (0 #1))
              , <RTLOP sub> #32 
                (FETCH_METHOD #32 (AGG-ID #32 ($W (0 #1))), 16 #32)
              )
            )
          , STORE_METHOD #1 
            (1-bits-at-loc #ungeneralized-2 #32 
              (7 #ungeneralized-2, AGG-ID #32 ($i (0 #3)))
            , FETCH_METHOD #1 (1-bits-at-loc #ungeneralized-3 #32 
                (6 #ungeneralized-3, AGG-ID #32 ($i (0 #3))))
            )
          )
        , STORE_METHOD #1 
          (1-bits-at-loc #ungeneralized-4 #32 
            (5 #ungeneralized-4, AGG-ID #32 ($i (0 #3)))
          , 1 #1
          )
        )
      , STORE_METHOD #32 (AGG-ID #32 ($i (5 #3)), address)
      ) : rtl

default attribute of ta address is SKIP : rtl

default attribute of tn address is SKIP : rtl

default attribute of tne address is SKIP : rtl

default attribute of te address is SKIP : rtl

default attribute of tg address is SKIP : rtl

default attribute of tle address is SKIP : rtl

default attribute of tge address is SKIP : rtl

default attribute of tl address is SKIP : rtl

default attribute of tgu address is SKIP : rtl

default attribute of tleu address is SKIP : rtl

default attribute of tcc address is SKIP : rtl

default attribute of tcs address is SKIP : rtl

default attribute of tpos address is SKIP : rtl

default attribute of tneg address is SKIP : rtl

default attribute of tvc address is SKIP : rtl

default attribute of tvs address is SKIP : rtl

default attribute of 
  rdy rd is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($r rd), FETCH_METHOD #32 (AGG-ID #32 ($i (3 #3)))
      ) : rtl

default attribute of 
  rdpsr rd is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($r rd), FETCH_METHOD #32 (AGG-ID #32 ($i (0 #3)))
      ) : rtl

default attribute of 
  rdwim rd is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($r rd), FETCH_METHOD #32 (AGG-ID #32 ($i (1 #3)))
      ) : rtl

default attribute of 
  rdtbr rd is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($r rd), FETCH_METHOD #32 (AGG-ID #32 ($i (2 #3)))
      ) : rtl

default attribute of 
  wry (rs1, reg_or_imm, rd) is 
    STORE_METHOD #32 
      (AGG-ID #32 ($i (3 #3))
      , <RTLOP xor> #32 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
      ) : rtl

default attribute of 
  wrpsr (rs1, reg_or_imm, rd) is 
    STORE_METHOD #32 
      (AGG-ID #32 ($i (0 #3))
      , <RTLOP xor> #32 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
      ) : rtl

default attribute of 
  wrwim (rs1, reg_or_imm, rd) is 
    STORE_METHOD #32 
      (AGG-ID #32 ($i (1 #3))
      , <RTLOP xor> #32 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
      ) : rtl

default attribute of 
  wrtbr (rs1, reg_or_imm, rd) is 
    STORE_METHOD #32 
      (AGG-ID #32 ($i (2 #3))
      , <RTLOP xor> #32 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
      ) : rtl

default attribute of 
  stbar () is STORE_METHOD #1 (AGG-ID #1 ($b (0 #1)), 1 #1) : rtl

default attribute of unimp imm22 is SKIP : rtl

default attribute of 
  fstoi (fs2, fd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($f fd)
      , <RTLOP f2i> #32 #32 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2)), <RTLOP zero>)
      ) : rtl

default attribute of 
  fdtoi (fs2, fd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($f fd)
      , <RTLOP f2i> #64 #32 
        (FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs2)), <RTLOP zero>)
      ) : rtl

default attribute of 
  fqtoi (fs2, fd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($f fd)
      , <RTLOP f2i> #128 #32 
        (FETCH_METHOD #128 (AGG_METHOD #32 #128 ($f fs2)), <RTLOP zero>)
      ) : rtl

default attribute of 
  fitos (fs2, fd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($f fd)
      , <RTLOP i2f> #32 #32 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fitod (fs2, fd) is 
    STORE_METHOD #64 
      (AGG_METHOD #32 #64 ($f fd)
      , <RTLOP i2f> #32 #64 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fitoq (fs2, fd) is 
    STORE_METHOD #128 
      (AGG_METHOD #32 #128 ($f fd)
      , <RTLOP i2f> #32 #128 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fstod (fs2, fd) is 
    STORE_METHOD #64 
      (AGG_METHOD #32 #64 ($f fd)
      , <RTLOP f2f> #32 #64 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fstoq (fs2, fd) is 
    STORE_METHOD #128 
      (AGG_METHOD #32 #128 ($f fd)
      , <RTLOP f2f> #32 #128 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fdtos (fs2, fd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($f fd)
      , <RTLOP f2f> #64 #32 
        (FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fdtoq (fs2, fd) is 
    STORE_METHOD #128 
      (AGG_METHOD #32 #128 ($f fd)
      , <RTLOP f2f> #64 #128 
        (FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fqtos (fs2, fd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($f fd)
      , <RTLOP f2f> #128 #32 
        (FETCH_METHOD #128 (AGG_METHOD #32 #128 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fqtod (fs2, fd) is 
    STORE_METHOD #64 
      (AGG_METHOD #32 #64 ($f fd)
      , <RTLOP f2f> #128 #64 
        (FETCH_METHOD #128 (AGG_METHOD #32 #128 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fmovs (fs2, fd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($f fd)
      , FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2))
      ) : rtl

default attribute of 
  fnegs (fs2, fd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($f fd)
      , <RTLOP negF> #32 (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2)))
      ) : rtl

default attribute of 
  fabss (fs2, fd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($f fd)
      , <RTLOP fabs> #32 (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2)))
      ) : rtl

default attribute of 
  fsqrts (fs2, fd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($f fd)
      , <RTLOP fsqrt> #32 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fsqrtd (fs2, fd) is 
    STORE_METHOD #64 
      (AGG_METHOD #32 #64 ($f fd)
      , <RTLOP fsqrt> #64 
        (FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fsqrtq (fs2, fd) is 
    STORE_METHOD #128 
      (AGG_METHOD #32 #128 ($f fd)
      , <RTLOP fsqrt> #128 
        (FETCH_METHOD #128 (AGG_METHOD #32 #128 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fadds (fs1, fs2, fd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($f fd)
      , <RTLOP addF> #32 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs1))
        , FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  faddd (fs1, fs2, fd) is 
    STORE_METHOD #64 
      (AGG_METHOD #32 #64 ($f fd)
      , <RTLOP addF> #64 
        (FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs1))
        , FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  faddq (fs1, fs2, fd) is 
    STORE_METHOD #128 
      (AGG_METHOD #32 #128 ($f fd)
      , <RTLOP addF> #128 
        (FETCH_METHOD #128 (AGG_METHOD #32 #128 ($f fs1))
        , FETCH_METHOD #128 (AGG_METHOD #32 #128 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fsubs (fs1, fs2, fd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($f fd)
      , <RTLOP subF> #32 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs1))
        , FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fsubd (fs1, fs2, fd) is 
    STORE_METHOD #64 
      (AGG_METHOD #32 #64 ($f fd)
      , <RTLOP subF> #64 
        (FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs1))
        , FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fsubq (fs1, fs2, fd) is 
    STORE_METHOD #128 
      (AGG_METHOD #32 #128 ($f fd)
      , <RTLOP subF> #128 
        (FETCH_METHOD #128 (AGG_METHOD #32 #128 ($f fs1))
        , FETCH_METHOD #128 (AGG_METHOD #32 #128 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fmuls (fs1, fs2, fd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($f fd)
      , <RTLOP mulF> #32 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs1))
        , FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fmuld (fs1, fs2, fd) is 
    STORE_METHOD #64 
      (AGG_METHOD #32 #64 ($f fd)
      , <RTLOP mulF> #64 
        (FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs1))
        , FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fmulq (fs1, fs2, fd) is 
    STORE_METHOD #128 
      (AGG_METHOD #32 #128 ($f fd)
      , <RTLOP mulF> #128 
        (FETCH_METHOD #128 (AGG_METHOD #32 #128 ($f fs1))
        , FETCH_METHOD #128 (AGG_METHOD #32 #128 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fdivs (fs1, fs2, fd) is 
    STORE_METHOD #32 
      (AGG_METHOD #32 #32 ($f fd)
      , <RTLOP divF> #32 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs1))
        , FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fdivd (fs1, fs2, fd) is 
    STORE_METHOD #64 
      (AGG_METHOD #32 #64 ($f fd)
      , <RTLOP divF> #64 
        (FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs1))
        , FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fdivq (fs1, fs2, fd) is 
    STORE_METHOD #128 
      (AGG_METHOD #32 #128 ($f fd)
      , <RTLOP divF> #128 
        (FETCH_METHOD #128 (AGG_METHOD #32 #128 ($f fs1))
        , FETCH_METHOD #128 (AGG_METHOD #32 #128 ($f fs2))
        , FETCH_METHOD #2 (2-bits-at-loc #ungeneralized-6 #32 
            (30 #ungeneralized-6, AGG-ID #32 ($F (0 #1))))
        )
      ) : rtl

default attribute of 
  fsmuld (fs1, fs2, fd) is 
    STORE_METHOD #64 
      (AGG_METHOD #32 #64 ($f fd)
      , <RTLOP fmulx> #32 #64 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs1))
        , FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2))
        )
      ) : rtl

default attribute of 
  fdmulq (fs1, fs2, fd) is 
    STORE_METHOD #128 
      (AGG_METHOD #32 #128 ($f fd)
      , <RTLOP fmulx> #64 #128 
        (FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs1))
        , FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs2))
        )
      ) : rtl

default attribute of 
  fcmps (fs1, fs2) is 
    STORE_METHOD #2 
      (2-bits-at-loc #ungeneralized-7 #32 
        (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))
      , <RTLOP cmpF> #32 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs1))
        , FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2))
        )
      ) : rtl

default attribute of 
  fcmpd (fs1, fs2) is 
    STORE_METHOD #2 
      (2-bits-at-loc #ungeneralized-7 #32 
        (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))
      , <RTLOP cmpF> #64 
        (FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs1))
        , FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs2))
        )
      ) : rtl

default attribute of 
  fcmpq (fs1, fs2) is 
    STORE_METHOD #2 
      (2-bits-at-loc #ungeneralized-7 #32 
        (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))
      , <RTLOP cmpF> #128 
        (FETCH_METHOD #128 (AGG_METHOD #32 #128 ($f fs1))
        , FETCH_METHOD #128 (AGG_METHOD #32 #128 ($f fs2))
        )
      ) : rtl

default attribute of 
  fcmpes (fs1, fs2) is 
    STORE_METHOD #2 
      (2-bits-at-loc #ungeneralized-7 #32 
        (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))
      , <RTLOP cmpF> #32 
        (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs1))
        , FETCH_METHOD #32 (AGG_METHOD #32 #32 ($f fs2))
        )
      ) : rtl

default attribute of 
  fcmped (fs1, fs2) is 
    STORE_METHOD #2 
      (2-bits-at-loc #ungeneralized-7 #32 
        (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))
      , <RTLOP cmpF> #64 
        (FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs1))
        , FETCH_METHOD #64 (AGG_METHOD #32 #64 ($f fs2))
        )
      ) : rtl

default attribute of 
  fcmpeq (fs1, fs2) is 
    STORE_METHOD #2 
      (2-bits-at-loc #ungeneralized-7 #32 
        (10 #ungeneralized-7, AGG-ID #32 ($F (0 #1)))
      , <RTLOP cmpF> #128 
        (FETCH_METHOD #128 (AGG_METHOD #32 #128 ($f fs1))
        , FETCH_METHOD #128 (AGG_METHOD #32 #128 ($f fs2))
        )
      ) : rtl

attribute annul_delay of 
  bne (target, annul) is 
    <RTLOP andalso> 
      (<RTLOP ne> #1 (annul, 0 #1)
      , NOT (<RTLOP NE> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
              (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
      ) : bool

attribute annul_delay of 
  be (target, annul) is 
    <RTLOP andalso> 
      (<RTLOP ne> #1 (annul, 0 #1)
      , NOT (<RTLOP E> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
              (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
      ) : bool

attribute annul_delay of 
  bg (target, annul) is 
    <RTLOP andalso> 
      (<RTLOP ne> #1 (annul, 0 #1)
      , NOT (<RTLOP G> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
              (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
      ) : bool

attribute annul_delay of 
  ble (target, annul) is 
    <RTLOP andalso> 
      (<RTLOP ne> #1 (annul, 0 #1)
      , NOT (<RTLOP LE> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
              (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
      ) : bool

attribute annul_delay of 
  bge (target, annul) is 
    <RTLOP andalso> 
      (<RTLOP ne> #1 (annul, 0 #1)
      , NOT (<RTLOP GE> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
              (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
      ) : bool

attribute annul_delay of 
  bl (target, annul) is 
    <RTLOP andalso> 
      (<RTLOP ne> #1 (annul, 0 #1)
      , NOT (<RTLOP L> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
              (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
      ) : bool

attribute annul_delay of 
  bgu (target, annul) is 
    <RTLOP andalso> 
      (<RTLOP ne> #1 (annul, 0 #1)
      , NOT (<RTLOP GU> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
              (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
      ) : bool

attribute annul_delay of 
  bleu (target, annul) is 
    <RTLOP andalso> 
      (<RTLOP ne> #1 (annul, 0 #1)
      , NOT (<RTLOP LEU> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
              (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
      ) : bool

attribute annul_delay of 
  bcc (target, annul) is 
    <RTLOP andalso> 
      (<RTLOP ne> #1 (annul, 0 #1)
      , NOT (<RTLOP CC> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
              (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
      ) : bool

attribute annul_delay of 
  bcs (target, annul) is 
    <RTLOP andalso> 
      (<RTLOP ne> #1 (annul, 0 #1)
      , NOT (<RTLOP CS> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
              (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
      ) : bool

attribute annul_delay of 
  bpos (target, annul) is 
    <RTLOP andalso> 
      (<RTLOP ne> #1 (annul, 0 #1)
      , NOT (<RTLOP POS> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
              (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
      ) : bool

attribute annul_delay of 
  bneg (target, annul) is 
    <RTLOP andalso> 
      (<RTLOP ne> #1 (annul, 0 #1)
      , NOT (<RTLOP NEG> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
              (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
      ) : bool

attribute annul_delay of 
  bvc (target, annul) is 
    <RTLOP andalso> 
      (<RTLOP ne> #1 (annul, 0 #1)
      , NOT (<RTLOP VC> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
              (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
      ) : bool

attribute annul_delay of 
  bvs (target, annul) is 
    <RTLOP andalso> 
      (<RTLOP ne> #1 (annul, 0 #1)
      , NOT (<RTLOP VS> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
              (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3))))))
      ) : bool

attribute annul_delay of 
  ba (target, annul) is <RTLOP ne> #1 (annul, 0 #1) : bool

attribute annul_delay of 
  bn (target, annul) is <RTLOP ne> #1 (annul, 0 #1) : bool

attribute trap of 
  ld (address, rd) is 
    --> 
      (<RTLOP ne> #ungeneralized-20 
        (<RTLOP modUn> #32 #ungeneralized-20 (address, 4 #ungeneralized-20)
        , 0 #ungeneralized-20
        )
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1)), <RTLOP mem_address_not_aligned>)
      ) : rtl

attribute trap of 
  ldsh (address, rd) is 
    --> 
      (<RTLOP ne> #ungeneralized-21 
        (<RTLOP modUn> #32 #ungeneralized-21 (address, 2 #ungeneralized-21)
        , 0 #ungeneralized-21
        )
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1)), <RTLOP mem_address_not_aligned>)
      ) : rtl

attribute trap of 
  lduh (address, rd) is 
    --> 
      (<RTLOP ne> #ungeneralized-22 
        (<RTLOP modUn> #32 #ungeneralized-22 (address, 2 #ungeneralized-22)
        , 0 #ungeneralized-22
        )
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1)), <RTLOP mem_address_not_aligned>)
      ) : rtl

attribute trap of 
  ldd (address, rd) is 
    --> 
      (<RTLOP ne> #ungeneralized-23 
        (<RTLOP modUn> #32 #ungeneralized-23 (address, 8 #ungeneralized-23)
        , 0 #ungeneralized-23
        )
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1)), <RTLOP mem_address_not_aligned>)
      ) : rtl

attribute trap of 
  st (rd, address) is 
    --> 
      (<RTLOP ne> #ungeneralized-24 
        (<RTLOP modUn> #32 #ungeneralized-24 (address, 4 #ungeneralized-24)
        , 0 #ungeneralized-24
        )
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1)), <RTLOP mem_address_not_aligned>)
      ) : rtl

attribute trap of 
  sth (rd, address) is 
    --> 
      (<RTLOP ne> #ungeneralized-25 
        (<RTLOP modUn> #32 #ungeneralized-25 (address, 2 #ungeneralized-25)
        , 0 #ungeneralized-25
        )
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1)), <RTLOP mem_address_not_aligned>)
      ) : rtl

attribute trap of 
  std (rd, address) is 
    --> 
      (<RTLOP ne> #ungeneralized-26 
        (<RTLOP modUn> #32 #ungeneralized-26 (address, 8 #ungeneralized-26)
        , 0 #ungeneralized-26
        )
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1)), <RTLOP mem_address_not_aligned>)
      ) : rtl

attribute trap of 
  swap (address, rd) is 
    --> 
      (<RTLOP ne> #ungeneralized-27 
        (<RTLOP modUn> #32 #ungeneralized-27 (address, 4 #ungeneralized-27)
        , 0 #ungeneralized-27
        )
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1)), <RTLOP mem_address_not_aligned>)
      ) : rtl

attribute trap of 
  jmpl (address, rd) is 
    --> 
      (<RTLOP ne> #ungeneralized-28 
        (<RTLOP modUn> #32 #ungeneralized-28 (address, 4 #ungeneralized-28)
        , 0 #ungeneralized-28
        )
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1)), <RTLOP mem_address_not_aligned>)
      ) : rtl

attribute trap of 
  ldc (address, cd) is 
    --> 
      (<RTLOP ne> #ungeneralized-29 
        (<RTLOP modUn> #32 #ungeneralized-29 (address, 4 #ungeneralized-29)
        , 0 #ungeneralized-29
        )
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1)), <RTLOP mem_address_not_aligned>)
      ) : rtl

attribute trap of 
  lddc (address, cd) is 
    --> 
      (<RTLOP ne> #ungeneralized-30 
        (<RTLOP modUn> #32 #ungeneralized-30 (address, 8 #ungeneralized-30)
        , 0 #ungeneralized-30
        )
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1)), <RTLOP mem_address_not_aligned>)
      ) : rtl

attribute trap of 
  ldcsr address is 
    --> 
      (<RTLOP ne> #ungeneralized-31 
        (<RTLOP modUn> #32 #ungeneralized-31 (address, 4 #ungeneralized-31)
        , 0 #ungeneralized-31
        )
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1)), <RTLOP mem_address_not_aligned>)
      ) : rtl

attribute trap of 
  taddcctv (rs1, reg_or_imm, rd) is 
    --> 
      (<RTLOP orelse> 
        (<RTLOP tag_overflows> 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
        , <RTLOP add_overflows> #32 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm, 0 #1)
        )
      , STORE_METHOD #7 (AGG-ID #7 ($t (0 #1)), <RTLOP tag_overflow>)
      ) : rtl

attribute trap of 
  tsubcctv (rs1, reg_or_imm, rd) is 
    --> 
      (<RTLOP orelse> 
        (<RTLOP tag_overflows> 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm)
        , <RTLOP sub_overflows> 
          (FETCH_METHOD #32 (AGG_METHOD #32 #32 ($r rs1)), reg_or_imm, 0 #1)
        )
      , STORE_METHOD #7 (AGG-ID #7 ($t (0 #1)), <RTLOP tag_overflow>)
      ) : rtl

attribute trap of 
  ta address is 
    --> 
      (<RTLOP A> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1))
        , <RTLOP trap_instruction> 
          (7-bits-at #ungeneralized-32 #32 (0 #ungeneralized-32, address))
        )
      ) : rtl

attribute trap of 
  tn address is 
    --> 
      (<RTLOP N> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1))
        , <RTLOP trap_instruction> 
          (7-bits-at #ungeneralized-33 #32 (0 #ungeneralized-33, address))
        )
      ) : rtl

attribute trap of 
  tne address is 
    --> 
      (<RTLOP NE> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1))
        , <RTLOP trap_instruction> 
          (7-bits-at #ungeneralized-34 #32 (0 #ungeneralized-34, address))
        )
      ) : rtl

attribute trap of 
  te address is 
    --> 
      (<RTLOP E> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1))
        , <RTLOP trap_instruction> 
          (7-bits-at #ungeneralized-35 #32 (0 #ungeneralized-35, address))
        )
      ) : rtl

attribute trap of 
  tg address is 
    --> 
      (<RTLOP G> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1))
        , <RTLOP trap_instruction> 
          (7-bits-at #ungeneralized-36 #32 (0 #ungeneralized-36, address))
        )
      ) : rtl

attribute trap of 
  tle address is 
    --> 
      (<RTLOP LE> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1))
        , <RTLOP trap_instruction> 
          (7-bits-at #ungeneralized-37 #32 (0 #ungeneralized-37, address))
        )
      ) : rtl

attribute trap of 
  tge address is 
    --> 
      (<RTLOP GE> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1))
        , <RTLOP trap_instruction> 
          (7-bits-at #ungeneralized-38 #32 (0 #ungeneralized-38, address))
        )
      ) : rtl

attribute trap of 
  tl address is 
    --> 
      (<RTLOP L> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1))
        , <RTLOP trap_instruction> 
          (7-bits-at #ungeneralized-39 #32 (0 #ungeneralized-39, address))
        )
      ) : rtl

attribute trap of 
  tgu address is 
    --> 
      (<RTLOP GU> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1))
        , <RTLOP trap_instruction> 
          (7-bits-at #ungeneralized-40 #32 (0 #ungeneralized-40, address))
        )
      ) : rtl

attribute trap of 
  tleu address is 
    --> 
      (<RTLOP LEU> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1))
        , <RTLOP trap_instruction> 
          (7-bits-at #ungeneralized-41 #32 (0 #ungeneralized-41, address))
        )
      ) : rtl

attribute trap of 
  tcc address is 
    --> 
      (<RTLOP CC> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1))
        , <RTLOP trap_instruction> 
          (7-bits-at #ungeneralized-42 #32 (0 #ungeneralized-42, address))
        )
      ) : rtl

attribute trap of 
  tcs address is 
    --> 
      (<RTLOP CS> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1))
        , <RTLOP trap_instruction> 
          (7-bits-at #ungeneralized-43 #32 (0 #ungeneralized-43, address))
        )
      ) : rtl

attribute trap of 
  tpos address is 
    --> 
      (<RTLOP POS> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1))
        , <RTLOP trap_instruction> 
          (7-bits-at #ungeneralized-44 #32 (0 #ungeneralized-44, address))
        )
      ) : rtl

attribute trap of 
  tneg address is 
    --> 
      (<RTLOP NEG> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1))
        , <RTLOP trap_instruction> 
          (7-bits-at #ungeneralized-45 #32 (0 #ungeneralized-45, address))
        )
      ) : rtl

attribute trap of 
  tvc address is 
    --> 
      (<RTLOP VC> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1))
        , <RTLOP trap_instruction> 
          (7-bits-at #ungeneralized-46 #32 (0 #ungeneralized-46, address))
        )
      ) : rtl

attribute trap of 
  tvs address is 
    --> 
      (<RTLOP VS> (FETCH_METHOD #4 (4-bits-at-loc #ungeneralized-5 #32 
            (20 #ungeneralized-5, AGG-ID #32 ($i (0 #3)))))
      , STORE_METHOD #7 
        (AGG-ID #7 ($t (0 #1))
        , <RTLOP trap_instruction> 
          (7-bits-at #ungeneralized-47 #32 (0 #ungeneralized-47, address))
        )
      ) : rtl

attribute trap of 
  unimp imm22 is 
    STORE_METHOD #7 (AGG-ID #7 ($t (0 #1)), <RTLOP illegal_instruction>) : rtl