<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def _rshift_arithmetic(self, shift_amount):
 """ 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 """


        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)