class BitRangeManager:
    # ZERO INDEXED
    def __init__(self, size):
        self.size = size
        # Initialize a single integer to represent all the bits.
        self.bit_array = 0  # Start with all bits set to 0.

    def set_range(self, start, amount):
        mask = (1 << amount) - 1
        mask <<= start
        self.bit_array |= mask

    def __repr__(self):
        """
        Return a string representation of the bit array as '1's and '0's.
        """
        # Generate the binary string representation of the large int  # pad to 'size' bits
        return f"{self.bit_array:0{self.size}b}"[::-1]


def count_zero_groups_from_int(number, bit_width=32):
    # Initialize count and the flag to track if we are in a zero group
    count = 0
    in_zero_group = False

    # Iterate over all bits of the integer, including leading zeros
    for i in range(bit_width - 1, -1, -1):  # Start from the most significant bit (MSB)
        # Check if the i-th bit is zero
        if (number & (1 << i)) == 0:
            if not in_zero_group:
                count += 1  # New group of zeros
                in_zero_group = True
        else:  # If the i-th bit is 1
            in_zero_group = False

    return count


def main():
    N, M = map(int, input().split())
    bitman = BitRangeManager(N)
    for _ in range(M):
        inp = tuple(map(int, input().split()))
        bitman.set_range(inp[0] - 1, inp[1] - inp[0] + 1)
    print(count_zero_groups_from_int(bitman.bit_array, bitman.size))


main()