import java.util.Arrays;
import java.util.Comparator;
import java.util.Objects;
import java.util.Scanner;

public class Main {
    private static final int m = 998_244_353;
    private static int[] distanceSet;
    private static int[] nActivated;
    private static int[] nStalled;
    private static int nextPow2;


    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        Pair<Integer,Integer>[] robots = new Pair[n];
        for (int i = 0; i < n; i++) {
            robots[i] = new Pair<>(scanner.nextInt(), scanner.nextInt());
        }
        Arrays.sort(robots, Comparator.comparing(Pair::getA));
        int[] x = new int[n];
        for (int i = 0; i < n; i++) {
            x[i] = robots[i].getA();
        }
        nActivated = new int[n];
        nStalled = new int[n];
        nActivated[n-1]=1;
        nStalled[n-1]=1;
        nextPow2 = nextPow2(n);
        distanceSet = new int[nextPow2*2-1];
        updateDistances(n-1, n-1);
        for (int i = n-2; i >=0; i--) {
            if(robots[i].getB()==1){
                nActivated[i] = (nActivated[i+1] + nStalled[i+1])%m;
                nStalled[i] = (nActivated[i+1] + nStalled[i+1])%m;
                updateDistances(i, i);
                continue;
            }
            int index = Arrays.binarySearch(x, i, n, x[i] + robots[i].getB() - 1);
            if(index>0){ //
                int indexOfLastActivated = getDistance(i+1, index+1);
                nActivated[i] = nActivated[indexOfLastActivated] % m;
                nStalled[i] = (nActivated[i+1] + nStalled[i+1]) % m;
                updateDistances(i, indexOfLastActivated);
            }else{
                index = -(index+1)-1;
                if(index==i){
                    nActivated[i] = (nActivated[i+1] + nStalled[i+1])%m;
                    nStalled[i] = (nActivated[i+1] + nStalled[i+1])%m;
                    updateDistances(i, i);
                }else{
                    int indexOfLastActivated = getDistance(i, index+1);
                    nActivated[i] = nActivated[indexOfLastActivated]%m;
                    nStalled[i] = (nActivated[i+1] + nStalled[i+1])%m;
                    updateDistances(i, indexOfLastActivated);
                }
            }
        }
        System.out.println((nActivated[0]+nStalled[0])%m);
    }

    private static int getDistance(int l, int r){
        return getDistance(0, 0, nextPow2, l, r);
    }

    private static int getDistance(int v, int l, int r, int ql, int qr){
        if (l >= qr || r <= ql) {
            return Integer.MIN_VALUE;
        }
        if (ql <= l && r <= qr) {
            return distanceSet[v];
        }
        int mid = (l + r) / 2;
        return Math.max(
                getDistance(v * 2 + 1, l, mid, ql, qr),
                getDistance(v * 2 + 2, mid, r, ql, qr)
        );
    }

    private static void updateDistances(int i, int value){
        i = nextPow2-1+i;
        distanceSet[i] = Math.max(distanceSet[i], value);
        i = (i-1)>>1;
        while (i>=0){
            distanceSet[i] = Math.max(distanceSet[i*2+1], distanceSet[i*2+2]);
            i = (i-1)>>1;
        }
    }
    public static class Pair<A, B> {
        private final A a;
        private final B b;

        public Pair(A a, B b) {
            this.a = a;
            this.b = b;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (o == null || getClass() != o.getClass()) return false;
            Pair<?, ?> pair = (Pair<?, ?>) o;
            return Objects.equals(a, pair.a) &&
                    Objects.equals(b, pair.b);
        }

        @Override
        public int hashCode() {
            return Objects.hash(a, b);
        }

        public A getA() {
            return a;
        }

        public B getB() {
            return b;
        }

        @Override
        public String toString() {
            return "Pair{" +
                    "a=" + a +
                    ", b=" + b +
                    '}';
        }
    }

    public static int nextPow2(int n) {
        if ((n & (n - 1)) == 0) return n;
        else return Integer.highestOneBit(n) << 1;
    }
}

Measured memory_bytes: 131684