code: def _rshift_arithmetic(self, shift_amount):
          
  
          if self.is_empty:
              return self
  
          # If straddling the north pole, we'll have to split it into two, perform arithmetic right shift on them
          # individually, then union the result back together for better precision. Note that it's an improvement from
          # the original WrappedIntervals paper.
  
          nsplit = self._nsplit()
          if len(nsplit) == 1:
              # preserve the highest bit :-)
              highest_bit_set = self.lower_bound > StridedInterval.signed_max_int(nsplit[0].bits)
  
              l = self.lower_bound >> shift_amount
              u = self.upper_bound >> shift_amount
              stride = max(self.stride >> shift_amount, 1)
              mask = ((2 ** shift_amount - 1) << (self.bits - shift_amount))
  
              if highest_bit_set:
                  l = l | mask
                  u = u | mask
              if l == u:
                  stride = 0
              return StridedInterval(bits=self.bits,
                                     lower_bound=l,
                                     upper_bound=u,
                                     stride=stride,
                                     uninitialized=self.uninitialized
                                     )
          else:
              a = nsplit[0]._rshift_arithmetic(shift_amount)
              b = nsplit[1]._rshift_arithmetic(shift_amount)
  
              return a.union(b)
docs: Arithmetic shift right with a concrete shift amount
  
          :param int shift_amount: Number of bits to shift right.
          :return: The new StridedInterval after right shifting
          :rtype: StridedInterval