# https://yukicoder.me/problems/no/3366

import random

MOD = 998244353




def main():
    N, M = map(int, input().split())
    lr = []
    for _ in range(M):
        l, r = map(int, input().split())
        lr.append((l , r ))

    # Zobrist_hash
    hash_table = set()
    while len(hash_table) < M:
        hash_table.add(random.randint(1, 1 << 63))
    zoblist_hash = list(hash_table)

    # 座標圧縮
    l_set = {1, N, N + 1}
    for l, r in lr:
        l_set.add(l)
        l_set.add(r)
        l_set.add(r + 1)
    l_list = list(l_set)
    l_list.sort()
    l_map = {}
    for i, l in enumerate(l_list):
        l_map[l] = i
    l_max = len(l_list)


    # イベントソート
    add_event = [[] for _ in range(l_max)]
    remove_event = [[] for _ in range(l_max)]
    for i in range(M):
        l, r = lr[i]
        l_ = l_map[l]
        r_ = l_map[r]
        add_event[l_].append(i)
        remove_event[r_].append(i)

    z_hash = 0
    z_hash_count = {}
    for i in range(l_max):
        for index in add_event[i]:
            z_hash ^= zoblist_hash[index]

        count = 0
        if i < l_max - 1:
            count = l_list[i + 1] - l_list[i]
        if z_hash not in z_hash_count:
            z_hash_count[z_hash] = 0
        z_hash_count[z_hash] += count

        for index in remove_event[i]:
            z_hash ^= zoblist_hash[index]

    
    n = 0
    for key, value in z_hash_count.items():
        if key != 0:
            n += value

    ans2 = 0
    for key, value in z_hash_count.items():
        if key != 0:
            c1 = value % MOD
            c2 = (n - value ) % MOD
            c3 = (c1 * c2) % MOD
            c3 *= pow(4, MOD - 2, MOD)
            c3 %= MOD

            c1 = value % MOD
            c2 = (value - 1) % MOD
            c4 = (c1 * c2) % MOD
            c4 *= pow(2, MOD - 2, MOD)
            c4 %= MOD
            ans2 += (c3 + c4) % MOD
            ans2 %= MOD
        else:
            n0 = N - value
            c0 = (2 * n0 * value) % MOD
            c0 *= pow(2, MOD -2, MOD)
            c0 %= MOD

            c0 += (pow(value, 2, MOD) - value) % MOD
            c0 %= MOD

            ans2 += c0
            ans2 %= MOD

    answer = (n * pow(2, MOD -2, MOD)) % MOD
    answer %= MOD
    answer += (N - n)
    answer %= MOD

    answer += ans2
    answer %= MOD

    answer *= pow(2, M, MOD)
    answer %= MOD
    print(answer)

    

if __name__ == "__main__":
    main()