Arkady the air traffic controller is now working with n planes in the air. All planes move along a straight coordinate axis with Arkady's station being at point 0 on it. The i-th plane, small enough to be represented by a point, currently has a coordinate of xi and is moving with speed vi. It's guaranteed that xi·vi < 0, i.e., all planes are moving towards the station.

Occasionally, the planes are affected by winds. With a wind of speed vwind (not necessarily positive or integral), the speed of the i-th plane becomes vi + vwind.

According to weather report, the current wind has a steady speed falling inside the range [ - w, w] (inclusive), but the exact value cannot be measured accurately since this value is rather small — smaller than the absolute value of speed of any plane.

Each plane should contact Arkady at the exact moment it passes above his station. And you are to help Arkady count the number of pairs of planes (i, j) (i < j) there are such that there is a possible value of wind speed, under which planes i and j contact Arkady at the same moment. This value needn't be the same across different pairs.

The wind speed is the same for all planes. You may assume that the wind has a steady speed and lasts arbitrarily long.

Input

The first line contains two integers n and w (1 ≤ n ≤ 100 000, 0 ≤ w < 105) — the number of planes and the maximum wind speed.

The i-th of the next n lines contains two integers xi and vi (1 ≤ |xi| ≤ 105, w + 1 ≤ |vi| ≤ 105, xi·vi < 0) — the initial position and speed of the i-th plane.

Planes are pairwise distinct, that is, no pair of (i, j) (i < j) exists such that both xi = xj and vi = vj.

Output

Output a single integer — the number of unordered pairs of planes that can contact Arkady at the same moment.

Examples

Input

5 1
-3 2
-3 3
-1 2
1 -3
3 -5


Output

3


Input

6 1
-3 2
-2 2
-1 2
1 -2
2 -2
3 -2


Output

9

Note

In the first example, the following 3 pairs of planes satisfy the requirements: 

  * (2, 5) passes the station at time 3 / 4 with vwind = 1; 
  * (3, 4) passes the station at time 2 / 5 with vwind = 1 / 2; 
  * (3, 5) passes the station at time 4 / 7 with vwind = - 1 / 4. 



In the second example, each of the 3 planes with negative coordinates can form a valid pair with each of the other 3, totaling 9 pairs.
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;
/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author chaku
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskC solver = new TaskC();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskC {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
                int n=in.nextInt(),w=in.nextInt();
                bit=new int[100010];
                int[] x=new int[n];
                int[] v=new int[n];
                for(int i=0;i<n;i++)
                {
                        x[i]=in.nextInt();
                        v[i]=in.nextInt();
                }
                Pair[][] pr=new Pair[n][2];
                for(int i=0;i<n;i++)
                {
                        int[] den=new int[2];
                        den[0]=v[i]+w;
                        den[1]=v[i]-w;
                        //Arrays.sort(den);
                        int num=x[i];
                        pr[i][0]=new Pair(num,den[1]);
                        pr[i][1]=new Pair(num,den[0]);
                }
                Arrays.sort(pr,new Comparator<Pair[]>(){
                        public int compare(Pair[] p1,Pair[] p2)
                        {
                                Pair f1=p1[1];
                                Pair f2=p2[1];
                                Pair s1=p1[0];
                                Pair s2=p2[0];
                                int v1=cmp(s1,s2);
                                if(v1!=0)return v1;
                                else 
                                {
                                    return cmp(f2,f1);
                                }
                        }
                });
                
                Pair[] list=new Pair[n];
                for(int i=0;i<n;i++)
                {
                    list[i]=new Pair(pr[i][1].a,pr[i][1].b);
                }
                Arrays.sort(list,new Comparator<Pair>(){
                    public int compare(Pair p1,Pair p2)
                    {
                        return cmp(p1,p2);
                    }
                });
                /*
                for(Pair p:list)
                {
                    out.println(p.a+" "+p.b);
                }
                */
                int ind=1;
                for(int i=1;i<n;i++)
                {
                    if(cmp(list[i],list[i-1])!=0)
                    {
                        list[ind++]=list[i];
                    }
                }
                list=Arrays.copyOf(list,ind);
                int[] d=new int[n];
                for(int i=0;i<n;i++)
                {
                    int index=Arrays.binarySearch(list,pr[i][1],new Comparator<Pair>(){
                      public int compare(Pair p1,Pair p2)
                      {
                        return cmp(p1,p2);
                      }
                    });
                    if(index<0)index=-index-2;
                    d[i]=index+1;
                    //out.println(d[i]);
                }
                long ans=0;
                for(int i=0;i<n;i++)
                {
                    ans+=query(n-d[i]+1);
                    add(n-d[i]+1,1,n);
                }
                out.println(ans);
                /*
                for(Pair p:list)
                {
                    out.println(p.a+" "+p.b);
                }
                
                for(Pair[] p:pr)
                {
                        System.out.println(p[0].a+" "+p[0].b+", "+p[1].a+" "+p[1].b);
                }
                */
                
        }
        
        public static int cmp(Pair p1,Pair p2)
        {
                long l=(long)p1.a*p2.b-(long)p1.b*p2.a;
                if(l>0)return 1;
                else if(l<0)return -1;
                return 0;
        }
        static int bit[];
        
        static void add(int x,int d,int n)
        {
            for(int i=x;i<=n;i+=i&-i)bit[i]+=d;
        }

        static int query(int x)
        {
            int ret=0;
            for(int i=x;i>0;i-=i&-i)ret+=bit[i];
            return ret;
        }
        
        static class Pair
        {
                int a;int b;
                public Pair(int a,int b)
                {
                        this.a=Math.abs(a);this.b=Math.abs(b);
                }
        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println(Object... objects) {
            print(objects);
            writer.println();
        }

        public void close() {
            writer.close();
        }

        public void println(int i) {
            writer.println(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public int read() {

            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int[] nextIntArray(int n) {
            int[] array = new int[n];
            for (int i = 0; i < n; ++i) array[i] = nextInt();
            return array;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}