import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;

public class Solver {

    public static void main(String[] Args) throws NumberFormatException,
            IOException {
        new Solver().Run();

    }

    PrintWriter pw;
    StringTokenizer Stok;
    BufferedReader br;

    public String nextToken() throws IOException {
        while (Stok == null || !Stok.hasMoreTokens()) {
            Stok = new StringTokenizer(br.readLine());
        }
        return Stok.nextToken();
    }

    public int nextInt() throws NumberFormatException, IOException {
        return Integer.parseInt(nextToken());
    }

    public double nextDouble() throws NumberFormatException, IOException {
        return Double.parseDouble(nextToken());
    }

    public long nextLong() throws NumberFormatException, IOException {
        return Long.parseLong(nextToken());
    }

    double k,t1,t2;

    public class Gnom {
        public int num;
        public double height;

        public Gnom(int aNum, double a, double b) {
            num = aNum;
            height = Math.floor(Math.max(a * t1 * k + b * t2, b * t1 * k
                     + a * t2) * 100)/100;
        }
    }

    public void Run() throws NumberFormatException, IOException {
        // br = new BufferedReader(new FileReader("input.txt"));
        // pw = new PrintWriter("output.txt");
        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new OutputStreamWriter(System.out));
        int n = nextInt();
        t1 = nextInt();
        t2 = nextInt();
        k = 100 - nextInt();
        k = k/100;
        Gnom[] Cont = new Gnom[n];
        for (int i = 0; i < n; i++) {
            Cont[i] = new Gnom(i + 1, nextInt(), nextInt());
        }
        Arrays.sort(Cont, new Comparator<Gnom>() {

            @Override
            public int compare(Gnom o1, Gnom o2) {
                if (o1.height != o2.height) {
                    if (o1.height>o2.height){
                        return -1;
                    } else {
                        return 1;
                    }
                } else {
                    return o1.num - o2.num;
                }
            }
        });
        for (int i = 0; i < n; i++) {
            pw.print(Cont[i].num);
            pw.print(' ');
            pw.format("%.2f%n", Cont[i].height);
        }
        pw.flush();
        pw.close();

    }

}


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;

public class Solver {

    public static void main(String[] Args) throws NumberFormatException,
            IOException {
        new Solver().Run();

    }

    PrintWriter pw;
    StringTokenizer Stok;
    BufferedReader br;

    public String nextToken() throws IOException {
        while (Stok == null || !Stok.hasMoreTokens()) {
            Stok = new StringTokenizer(br.readLine());
        }
        return Stok.nextToken();
    }

    public int nextInt() throws NumberFormatException, IOException {
        return Integer.parseInt(nextToken());
    }

    public double nextDouble() throws NumberFormatException, IOException {
        return Double.parseDouble(nextToken());
    }

    public long nextLong() throws NumberFormatException, IOException {
        return Long.parseLong(nextToken());
    }

    double k,t1,t2;

    public class Gnom {
        public int num;
        public double height;

        public Gnom(int aNum, double a, double b) {
            num = aNum;
            height = StrictMath.floor(StrictMath.max(a * t1 * k + b * t2, b * t1 * k
                     + a * t2) * 100)/100;
        }
    }

    public void Run() throws NumberFormatException, IOException {
        // br = new BufferedReader(new FileReader("input.txt"));
        // pw = new PrintWriter("output.txt");
        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new OutputStreamWriter(System.out));
        int n = nextInt();
        t1 = nextDouble();
        t2 = nextDouble();
        k = 100 - nextDouble();
        k = k/100;
        Gnom[] Cont = new Gnom[n];
        for (int i = 0; i < n; i++) {
            Cont[i] = new Gnom(i + 1, nextDouble(), nextDouble());
        }
        Arrays.sort(Cont, new Comparator<Gnom>() {

            @Override
            public int compare(Gnom o1, Gnom o2) {
                if (o1.height != o2.height) {
                    if (o1.height>o2.height){
                        return -1;
                    } else {
                        return 1;
                    }
                } else {
                    return o1.num - o2.num;
                }
            }
        });
        for (int i = 0; i < n; i++) {
            pw.print(Cont[i].num);
            pw.print(' ');
            pw.format("%.2f%n", Cont[i].height);
        }
        pw.flush();
        pw.close();

    }

}


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;

public class Solver {

    public static void main(String[] Args) throws NumberFormatException,
            IOException {
        new Solver().Run();

    }

    PrintWriter pw;
    StringTokenizer Stok;
    BufferedReader br;

    public String nextToken() throws IOException {
        while (Stok == null || !Stok.hasMoreTokens()) {
            Stok = new StringTokenizer(br.readLine());
        }
        return Stok.nextToken();
    }

    public int nextInt() throws NumberFormatException, IOException {
        return Integer.parseInt(nextToken());
    }

    public double nextDouble() throws NumberFormatException, IOException {
        return Double.parseDouble(nextToken());
    }

    public long nextLong() throws NumberFormatException, IOException {
        return Long.parseLong(nextToken());
    }

    double k,t1,t2;

    public class Gnom {
        public int num;
        public double height;

        public Gnom(int aNum, double a, double b) {
            num = aNum;
            height = StrictMath.round(StrictMath.max(a * t1 * k + b * t2, b * t1 * k
                     + a * t2) * 100)*0.01;
        }
    }

    public void Run() throws NumberFormatException, IOException {
        // br = new BufferedReader(new FileReader("input.txt"));
        // pw = new PrintWriter("output.txt");
        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new OutputStreamWriter(System.out));
        int n = nextInt();
        t1 = nextDouble();
        t2 = nextDouble();
        k = 100 - nextDouble();
        k = k/100;
        Gnom[] Cont = new Gnom[n];
        for (int i = 0; i < n; i++) {
            Cont[i] = new Gnom(i + 1, nextDouble(), nextDouble());
        }
        Arrays.sort(Cont, new Comparator<Gnom>() {

            @Override
            public int compare(Gnom o1, Gnom o2) {
                if (o1.height != o2.height) {
                    if (o1.height>o2.height){
                        return -1;
                    } else {
                        return 1;
                    }
                } else {
                    return o1.num - o2.num;
                }
            }
        });
        for (int i = 0; i < n; i++) {
            pw.print(Cont[i].num);
            pw.print(' ');
            pw.format("%.2f%n", Cont[i].height);
        }
        pw.flush();
        pw.close();

    }

}


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.StringTokenizer;

public class Solver {

    public static void main(String[] Args) throws NumberFormatException,
            IOException {
        new Solver().Run();

    }

    PrintWriter pw;
    StringTokenizer Stok;
    BufferedReader br;

    public String nextToken() throws IOException {
        while (Stok == null || !Stok.hasMoreTokens()) {
            Stok = new StringTokenizer(br.readLine());
        }
        return Stok.nextToken();
    }

    public int nextInt() throws NumberFormatException, IOException {
        return Integer.parseInt(nextToken());
    }

    public double nextDouble() throws NumberFormatException, IOException {
        return Double.parseDouble(nextToken());
    }

    public long nextLong() throws NumberFormatException, IOException {
        return Long.parseLong(nextToken());
    }

    int k, t1, t2;

    public class Gnom {
        public int num;
        public double height;

        public Gnom(int aNum, double a, double b) {
            num = aNum;
            height = Math.floor(Math.max(a * t1 * k / 100 + b * t2, b * t1 * k
                    / 100 + a * t2) * 100);
        }
    }

    public void Run() throws NumberFormatException, IOException {
        // br = new BufferedReader(new FileReader("input.txt"));
        // pw = new PrintWriter("output.txt");
        br = new BufferedReader(new InputStreamReader(System.in));
        pw = new PrintWriter(new OutputStreamWriter(System.out));
        int n = nextInt();
        t1 = nextInt();
        t2 = nextInt();
        k = 100 - nextInt();
        Gnom[] Cont = new Gnom[n];
        for (int i = 0; i < n; i++) {
            Cont[i] = new Gnom(i + 1, nextInt(), nextInt());
        }
        Arrays.sort(Cont, new Comparator<Gnom>() {

            @Override
            public int compare(Gnom o1, Gnom o2) {
                if (o1.height != o2.height) {
                    return (int) (o2.height - o1.height);
                } else {
                    return o1.num - o2.num;
                }
            }
        });
        for (int i = 0; i < n; i++) {
            pw.print(Cont[i].num);
            pw.print(' ');
            pw.format("%.2f%n", Cont[i].height / 100);
        }
        pw.flush();
        pw.close();

    }

}


import java.io.*;
import java.text.DecimalFormat;
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner in= new Scanner(System.in);
        int n,t1,t2; double k;
        DecimalFormat df= new DecimalFormat(".00");
        n=in.nextInt(); t1=in.nextInt();
        t2=in.nextInt(); k=in.nextInt();
        k= k/100;
        ArrayList<p> players= new ArrayList<p>();
        for (int i = 0; i < n; i++) {
            int s1= in.nextInt(); int s2= in.nextInt();
            double sum1= (s1*t1)-(s1*t1)*k+(s2*t2);
            double sum2= (s2*t1)-(s2*t1)*k+(s1*t2);
            if(sum1>sum2)
                players.add(new p(i+1,new Double(df.format(sum1)) ));
            else
                players.add(new p(i+1,new Double(df.format(sum2)) ));
        }
        Collections.sort(players);
        for(p pl : players){
            System.out.print(pl.ind+" "+pl.time);
            if(pl.time.toString().split("[.]")[1].length()==1)
                System.out.print("0");
            System.out.print("\n");
        }

    }

}

class p implements Comparable<p>{
    int ind;
    Double time;
    p(int i,double d){
        ind=i; time=d;
    }

    public int compareTo(p o) {
        if(this.time==o.time){
            if(this.ind>o.ind)
                return 1;
            else return -1;
        }
        if(this.time<o.time)
            return 1;
        return -1;
    }
}


import java.io.*;
import java.util.*;

public class PascalVsC {
	public static void main(String[] args) throws IOException {
		BufferedReader rd = new BufferedReader(new InputStreamReader(System.in));
		PrintWriter pw = new PrintWriter(System.out);
		StringTokenizer st = new StringTokenizer(rd.readLine());
		N = Integer.parseInt(st.nextToken());
		t1 = Integer.parseInt(st.nextToken());
		t2 = Integer.parseInt(st.nextToken());
		K = Integer.parseInt(st.nextToken());
		Part[] A = new Part[N];
		for(int i=0; i<N; i++){
			st = new StringTokenizer(rd.readLine());
			int a = Integer.parseInt(st.nextToken()), b = Integer.parseInt(st.nextToken());
			A[i] = new Part();
			A[i].index = i;
			A[i].point = Math.max(a*t1*(100-K)+100*b*t2, b*t1*(100-K)+100*a*t2);
		}
		Arrays.sort(A, new cmpParts());
		for(int i=0; i<A.length; i++){
			pw.println((1+A[i].index)+" "+toDouble(A[i].point));
		}
		pw.flush();
	}

	static String toDouble(int pt){
		String s = ""+pt;
		if(s.length()==1) return "0.0"+s;
		if(s.length()==2) return "0."+s;
		return s.substring(0, s.length()-2)+"."+s.charAt(s.length()-2)+s.charAt(s.length()-1);
	}

	static int N, t1, t2, K;

}

class Part{
	public int index = 0, point = 0;
}

class cmpParts implements Comparator{

	@Override
	public int compare(Object arg0, Object arg1) {
		Part fir = (Part)arg0, sec = (Part) arg1;
		if(fir.point!=sec.point) return -fir.point+sec.point;
		return fir.index-sec.index;
	}

}


import java.util.Arrays;
import java.util.Scanner;

public class A4 {
    public static void main(String[] args) {
        Scanner theIn=new Scanner(System.in);
        int n=theIn.nextInt();
        int t1=theIn.nextInt();
        int t2=theIn.nextInt();
        int k=theIn.nextInt();
        Gnome[] gnomes=new Gnome[n];

        for (int i=1; i<=n; i++) {
            int v1=theIn.nextInt();
            int v2=theIn.nextInt();
            double height=0.0;
            double m=(double) (100-k);
            m/=100;
            if ((m*v1*t1+v2*t2)>(m*v2*t1+v1*t2)) height=m*v1*t1+v2*t2;
                else height=m*v2*t1+v1*t2;
            gnomes[i-1]=new Gnome(i, height);
        }
        Arrays.sort(gnomes);
        for (int i=n; i>=1; i--) {
            System.out.println(gnomes[i-1].number+" "+String.format("%.2f", gnomes[i-1].height));
        }

    }
}
class Gnome implements Comparable<Gnome> {
    double height;
    int number;
    Gnome (int number, double height) {
        this.number=number;
        this.height=height;
    }
    public int compareTo(Gnome x) {
        if ((height-x.height)>0) return 1;
        if ((height-x.height)<0) return -1;
        if (number>x.number) return -1; else return 1;
    }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;

public class BBB {
	static class mushroom implements Comparable<mushroom> {
		int num;
		double score;

		public mushroom(int n, double s) {
			num = n;
			score = s;
		}

		public int compareTo(mushroom arg0) {
			if (Math.abs(score - arg0.score) < 1e-9)
				return num - arg0.num;
			else
				return (score - arg0.score) < 0 ? 1 : -1;
		}
	}

	public static void main(String[] args) throws IOException {
		BufferedReader buff = new BufferedReader(new InputStreamReader(
				System.in));

		String input = buff.readLine();
		StringTokenizer st = new StringTokenizer(input);
		int n = Integer.parseInt(st.nextToken());
		int t1 = Integer.parseInt(st.nextToken());
		int t2 = Integer.parseInt(st.nextToken());
		int k = Integer.parseInt(st.nextToken());

		mushroom[] array = new mushroom[n];

		for (int i = 0; i < n; i++) {
			st = new StringTokenizer(buff.readLine());
			int v = Integer.parseInt(st.nextToken());
			int u = Integer.parseInt(st.nextToken());

			double firstHeight = v * t1;
			double secondHeight = (firstHeight - (k / 100.0) * firstHeight) + u
					* t2;

			double firstHeight1 = u * t1;
			double secondHeight1 = (firstHeight1 - (k / 100.0) * firstHeight1)
					+ v * t2;

			array[i] = new mushroom(i + 1, Math
					.max(secondHeight, secondHeight1));
		}
		Arrays.sort(array);
		for (int i = 0; i < array.length; i++) {
			System.out.printf("%d %.2f\n", array[i].num, array[i].score);
		}
	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;

public class B {
    public static void main(String[] args) throws IOException {
        BufferedReader buff = new BufferedReader(new InputStreamReader(
                System.in));
        StringTokenizer tok = new StringTokenizer(buff.readLine());
        double n = new Integer(tok.nextToken()), t1 = new Integer(
                tok.nextToken()), t2 = new Integer(tok.nextToken()), k = new Integer(
                tok.nextToken()) / 100.0;
        ArrayList<entry> lst = new ArrayList<entry>(1000);

        for (int i = 0; i < n; i++) {
            tok = new StringTokenizer(buff.readLine());
            double v1 = new Integer(tok.nextToken()), v2 = new Integer(
                    tok.nextToken());
            double d1 = v1 * t1, d2 = v2 * t2;
            double d3 = v1 * t2, d4 = v2 * t1;
            double tmp1;
            tmp1 = Math.max(d1 - (d1 * k) + d2, d4 - (d4 * k) + d3);
            long tmp2 = (long) (tmp1 * 1000);
            tmp1 = Math.round(tmp2 / 10.0);
            lst.add(new entry(tmp1 / 100.0, i + 1));
        }
        Collections.sort(lst);
        for (int i = lst.size() - 1; i >= 0; i--) {
            System.out.printf("%d %.2f\n", lst.get(i).no, lst.get(i).len);
        }
    }

    static class entry implements Comparable<entry> {
        double len;
        int no;

        public entry(double len, int no) {
            this.len = len;
            this.no = no;
        }

        @Override
        public int compareTo(entry arg0) {
            if (len - arg0.len < 0)
                return -1;
            return 1;

        }
    }
}


import java.text.DecimalFormat;
import java.util.PriorityQueue;
import java.util.Scanner;

public class B {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        DecimalFormat f = new DecimalFormat("0.00");
        int n = in.nextInt();
        int t1 = in.nextInt();
        int t2 = in.nextInt();
        double k = (100 - in.nextDouble()) / 100.;
        PriorityQueue<myPoint> P = new PriorityQueue<myPoint>();
        for (int i = 0; i < n; i++) {
            double a = in.nextDouble();
            double b = in.nextDouble();
            double way1 = a * t1 * k + b * t2;
            double way2 = b * t1 * k + a * t2;
            P.add(new myPoint(i + 1, Math.max(way1, way2)));
        }
        while (!P.isEmpty()) {
            myPoint temp = P.poll();
            System.out.println(temp.index + " " + f.format(temp.h));
        }
    }
}

class myPoint implements Comparable<myPoint> {
    int index;
    double h;

    public myPoint(int i, double j) {
        index = i;
        h = j;
    }

    public int compareTo(myPoint o) {
        if (h < o.h)
            return 1;
        else if (o.h < h)
            return -1;
        else
            return index - o.index;
    }

}


import java.io.IOException;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Arrays;

/**
 * @author Sergey Vorobyev (svorobyev@spb.com)
 */
public class B {

    StreamTokenizer in;
    PrintWriter out;

    public static void main(String[] args) throws Exception {
        B instance = new B();
        instance.go();
    }

    int ni() throws IOException {
        in.nextToken();
        return (int)in.nval;
    }

    private int t1, t2, k, n;

    class Gnom implements Comparable<Gnom> {

        final double l;
        final int num;

        double calc(int f, int s) {
            return f * t1 * (1.0 - (k / 100.0)) + s * t2;
        }

        Gnom(int a, int b, int num) {
            l = Math.max(calc(a, b), calc(b, a));
            this.num = num;
        }

        @Override
        public int compareTo(Gnom gnom) {
            int res = Double.compare(gnom.l, l);
            if (res == 0) {
                return num - gnom.num;
            } else {
                return res;
            }
        }
    }

    private void go() throws Exception {
        in = new StreamTokenizer(System.in);
        out = new PrintWriter(System.out);

        n = ni();
        t1 = ni();
        t2 = ni();
        k = ni();

        Gnom[] a = new Gnom[n];

        for (int i=0; i<n; i++) {
            a[i] = new Gnom(ni(), ni(), i);
        }

        Arrays.sort(a);

        for (int i=0; i<n; i++) {
            out.printf("%d %.2f\n", a[i].num+1, a[i].l);
        }

        out.close();
    }
}


import java.util.Arrays;
import java.util.Scanner;

public class B118div2 {

	static class P implements Comparable<P>{
		long a;
		long b;
		long v;
		int i;
		public P(int i, int ai, int bi) {
			this.i = i;
			this.a = ai;
			this.b = bi;
			v = Math.max(t1*a*(100-k) + t2*b*100, t1*b*(100-k) + t2*a*100);
		}
		@Override
		public int compareTo(P arg0) {
			long dv = v - arg0.v;
			if(dv < 0)
				return -1;
			if(dv > 0)
				return 1;
			return  arg0.i - i;
		}
		@Override
		public String toString() {
			int r = (int)(v%100);
			return (i+1) + " " + (v/100) + "." + (r < 10 ? "0" + r : r);
		}

	}
	static int t1;
	static int t2;
	static int k;
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		t1 = sc.nextInt();
		t2 = sc.nextInt();
		k = sc.nextInt();
		P[] p = new P[n];
		for (int i = 0; i < n; i++) {
			int a = sc.nextInt();
			int b = sc.nextInt();
			p[i] = new P(i, a, b);
		}
		Arrays.sort(p);
		for (int i = n-1; i >= 0; i--) {
			System.out.println(p[i].toString());
		}

	}

}


/*
 ID: antonio13
 LANG: JAVA
 PROG: bb
 */
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * @author antonio081014
 * @time: 2012-5-4, 8:42:7
 */

public class bb {
    public static void main(String[] args) throws Exception {
	bb main = new bb();
	main.run();
	System.exit(0);
    }

    public void run() throws Exception {
	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
	// BufferedWriter out = new BufferedWriter(new FileWriter("bb.out"));
	// out.close();
	String[] str = br.readLine().split("\\s");
	int n = Integer.parseInt(str[0]);
	int t1 = Integer.parseInt(str[1]);
	int t2 = Integer.parseInt(str[2]);
	int k = Integer.parseInt(str[3]);

	List<Mushroom> list = new ArrayList<Mushroom>();
	for (int i = 0; i < n; i++) {
	    str = br.readLine().split("\\s");
	    int a = Integer.parseInt(str[0]);
	    int b = Integer.parseInt(str[1]);
	    double h1 = 1.0 * a * t1 * (100.0 - k) / 100.0 + 1.0 * b * t2;
	    double h2 = 1.0 * b * t1 * (100.0 - k) / 100.0 + 1.0 * a * t2;
	    if (h1 >= h2)
		list.add(new Mushroom(i + 1, h1));
	    else
		list.add(new Mushroom(i + 1, h2));
	}

	Collections.sort(list);
	for (int i = 0; i < n; i++) {
	    System.out.println(String.format("%d %.2f", list.get(i).id,
		    list.get(i).height));
	}
    }
}

class Mushroom implements Comparable<Mushroom> {
    public int id;
    public double height;

    public Mushroom(int id, double h) {
	this.id = id;
	this.height = h;
    }

    public int compareTo(Mushroom m) {
	double tmp = m.height - this.height;
	if (tmp > 0)
	    return 1;
	if (tmp < 0)
	    return -1;
	return this.id - m.id;
    }
}


import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
/**
 *
 * @author pttrung
 */

/*
 * aaaaaaaaa

 aaa

 */
public class B {

    public static int Mod = 1000003;

    public static void main(String[] args) throws FileNotFoundException {

        Scanner in = new Scanner();
        PrintWriter out = new PrintWriter(System.out);
        int n = in.nextInt();
        int t1 = in.nextInt();
        int t2 = in.nextInt();
        int k = in.nextInt();
        int[] x = new int[n];
        int[] y = new int[n];
        for (int i = 0; i < n; i++) {
            x[i] = in.nextInt();
            y[i] = in.nextInt();
        }
        MushRoom[] result = new MushRoom[n];
        for (int i = 0; i < n; i++) {
            double a = x[i] * t1 * ((double) (100 - k) / 100);
            a += y[i] * t2;
            double b = y[i]*t1 * ((double) (100 - k)/100);
            b += x[i]*t2;
            result[i] = new MushRoom((i + 1) , Math.max(a,b));
        }
        Arrays.sort(result);
        for(int i = 0 ; i < n; i++){
            out.printf("%d %.2f\n" , result[i].index , result[i].height);
        }
        out.close();
    }

    public static class MushRoom implements Comparable<MushRoom> {

        int index;
        double height;

        public MushRoom(int index, double height) {
            this.index = index;
            this.height = height;
        }

        @Override
        public int compareTo(MushRoom o) {
            if(height != o.height){
                if(height > o.height){
                    return -1;
                }else{
                    return 1;
                }
            }
            return index - o.index;
        }
    }

    public static boolean nextPer(int[] data) {
        int i = data.length - 1;
        while (i > 0 && data[i] < data[i - 1]) {
            i--;
        }
        if (i == 0) {
            return false;
        }
        int j = data.length - 1;
        while (data[j] < data[i - 1]) {
            j--;
        }
        int temp = data[i - 1];
        data[i - 1] = data[j];
        data[j] = temp;
        Arrays.sort(data, i, data.length);
        return true;
    }

    public static class Point {

        int x, y;

        public Point(int x, int y) {
            this.x = x;
            this.y = y;

        }
    }

    public static long pow(long a, int b) {
        if (b == 0) {
            return 1;
        }
        if (b == 1) {
            return a;
        }
        long val = pow(a, b / 2);
        if (b % 2 == 0) {
            return val * val;
        } else {
            return val * (val * a);
        }
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long lcm(long a, long b) {
        return a * b / gcd(a, b);
    }

    static class Scanner {

        BufferedReader br;
        StringTokenizer st;

        public Scanner() throws FileNotFoundException {
            //System.setOut(new PrintStream(new BufferedOutputStream(System.out), true));
            br = new BufferedReader(new InputStreamReader(System.in));
            // br = new BufferedReader(new InputStreamReader(new FileInputStream(new File("square_detector.txt"))));
        }

        public String next() {

            while (st == null || !st.hasMoreTokens()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (Exception e) {
                    throw new RuntimeException();
                }
            }
            return st.nextToken();
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            st = null;
            try {
                return br.readLine();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }

        public boolean endLine() {
            try {
                String next = br.readLine();
                while (next != null && next.trim().isEmpty()) {
                    next = br.readLine();
                }
                if (next == null) {
                    return true;
                }
                st = new StringTokenizer(next);
                return st.hasMoreTokens();
            } catch (Exception e) {
                throw new RuntimeException();
            }
        }
    }
}


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

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Dilshan
 */
public class mushrooms {
   public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
      int n=s.nextInt();
        double t1=s.nextDouble();
        double t2=s.nextDouble();
        double k=s.nextDouble();
        double l=0;
       double m=0;
        double z=0;
        double f=0;
        double g=0;
       double[][] x=new double[n][2];
        for(int i=0;i<n;++i){
            l=s.nextDouble();
            m=s.nextDouble();
            z=mushrooms.max(l,m,t1,t2,k);
            x[i][1]=z;
             x[i][0]=(i+1);
           // System.out.println("ded"+z);

        }
        Arrays.sort(x, new Comparator<double[]>() {
            @Override
            public int compare(double[] o1, double[] o2) {
                double a1=o1[1];
                double a2=o2[1];
                if (a1>=a2)
                      return -1;
                else
                    return 1;
            }
        });

       for(int i=0;i<n;++i){

               System.out.print((int)(x[i][0])+" ");
                System.out.printf("%.2f", x[i][1]);
                System.out.println();

       }
    }
//
    private static double max(double p, double q , double r, double s, double t) {
        double max=0;
        double f=(p*r)*(1-(t/100))+q*s;
        double g=((q*r)*(1-(t/100))+p*s);

        if(f>g)
            return f;
        else
            return g;
    }

}


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

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author Dilshan
 */
public class mushrooms {
   public static void main(String[] args) {
        Scanner s=new Scanner(System.in);
      int n=s.nextInt();
        double t1=s.nextDouble();
        double t2=s.nextDouble();
        double k=s.nextDouble();
        double l=0;
       double m=0;
        double z=0;
        double f=0;
        double g=0;
       double[][] x=new double[n][2];
        for(int i=0;i<n;++i){
            l=s.nextDouble();
            m=s.nextDouble();
            z=mushrooms.max(l,m,t1,t2,k);
            x[i][1]=z;
             x[i][0]=(i+1);
           // System.out.println("ded"+z);

        }
        Arrays.sort(x, new Comparator<double[]>() {
            @Override
            public int compare(double[] o1, double[] o2) {
                double a1=o1[1];
                double a2=o2[1];
                if (a1>=a2)
                      return -1;
                else
                    return 1;
            }
        });

       for(int i=0;i<n;++i){

               System.out.print((int)(x[i][0])+" ");
               System.out.println(x[i][1]);
       }
    }
//
    private static double max(double p, double q , double r, double s, double t) {
        double max=0;
        double f=(p*r)*(1-(t/100))+q*s;
        double g=((q*r)*(1-(t/100))+p*s);

        if(f>g)
            return f;
        else
            return g;
    }

}


import java.util.Arrays;
import java.util.Scanner;
import java.text.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Collections;

public class Main
{//main

    static double mushroomHeight(int t1, int t2, double k, int a, int b){
       double height = (a*t1)*(1-k/100)+b*t2;
       return height;
    }

  public static void main (String[] args) throws java.lang.Exception
  {// Reading strings using Scanner
   Scanner scan = new Scanner(System.in);
   int n = scan.nextInt();
   int t1 = scan.nextInt();
   int t2 = scan.nextInt();
   int k = scan.nextInt();
   int a;
   int b;
   double result;
   List<Gnome> Gnomes = new ArrayList<Gnome>();

   for (int i=0; i<n; i++){
       a=scan.nextInt();
       b=scan.nextInt();
       result=mushroomHeight(t1,t2,k,a,b);
       if (result<mushroomHeight(t1,t2,k,b,a)){
           result=mushroomHeight(t1,t2,k,b,a);
       }
       Gnomes.add(new Gnome(i,result));
   }
   Collections.sort(Gnomes);
   DecimalFormat df = new DecimalFormat("##.00");
   for(Gnome x: Gnomes)//printing the sorted list
   System.out.println(x.getGnomeNumber()+1 +" "+
     df.format(x.getGnomeResult()));
  }
}
  class Gnome implements Comparator<Gnome>, Comparable<Gnome>{
 private int number;
 private double result;
 Gnome(){
 }

 Gnome(int num, double res){
     number = num;
     result = res;
 }

 public int getGnomeNumber(){
    return number;
 }

 public double getGnomeResult(){
     return result;
 }

  public int compareTo(Gnome g){
      return ((this.result>g.result) ? -1:
              ((this.result)<g.result) ? 1:
              ((this.number<g.number)? -1:1));
   }
 public int compare(Gnome g1, Gnome g2){
      return ((g1.result>g2.result) ? -1:
              ((g1.result)<g2.result) ? 1:
              ((g1.number<g2.number)? -1:1));
   }
}


import java.util.Arrays;
import java.util.Scanner;
import java.text.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Collections;

public class Main
{//main

    static double mushroomHeight(int t1, int t2, double k, int a, int b){
       double height = (a*t1)*(1-k/100)+b*t2;
       return height;
    }

  public static void main (String[] args) throws java.lang.Exception
  {// Reading strings using Scanner
   Scanner scan = new Scanner(System.in);
   int n = scan.nextInt();
   int t1 = scan.nextInt();
   int t2 = scan.nextInt();
   int k = scan.nextInt();
   int a;
   int b;
   double[] result = new double[n];

   List<Gnome> Gnomes = new ArrayList<Gnome>();

   for (int i=0; i<n; i++){
       a=scan.nextInt();
       b=scan.nextInt();
       result[i]=mushroomHeight(t1,t2,k,a,b);
       if (result[i]<mushroomHeight(t1,t2,k,b,a)){
           result[i]=mushroomHeight(t1,t2,k,b,a);
       }

       Gnomes.add(new Gnome(i,result[i]));
   }
   Collections.sort(Gnomes);
   DecimalFormat df = new DecimalFormat("##.00");
   for(Gnome x: Gnomes)//printing the sorted list
   System.out.println(x.getGnomeNumber()+1 +" "+
     df.format(x.getGnomeResult()));
  // for (int i=0; i<result.length;i++)
  //     System.out.println(df.format(result[i]));
  }

class Gnome implements Comparator<Gnome>, Comparable<Gnome>{
 private int number;
 private double result;
 Gnome(){
 }

 Gnome(int num, double res){
     number = num;
     result = res;
 }

 public int getGnomeNumber(){
    return number;
 }

 public double getGnomeResult(){
     return result;
 }

  public int compareTo(Gnome g){
      return ((this.result>g.result) ? -1:
              ((this.result)<g.result) ? 1:
              ((this.number<g.number)? -1:1));
   }
 public int compare(Gnome g1, Gnome g2){
      return ((g1.result>g2.result) ? -1:
              ((g1.result)<g2.result) ? 1:
              ((g1.number<g2.number)? -1:1));
   }
}

}


import java.util.Arrays;
import java.util.Scanner;
import java.text.*;
import java.util.List;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.Collections;

public class Main
{//main

    static double mushroomHeight(int t1, int t2, double k, int a, int b){
       double height = (a*t1)*(1-k/100)+b*t2;
       return height;
    }

  public static void main (String[] args) throws java.lang.Exception
  {// Reading strings using Scanner
   Scanner scan = new Scanner(System.in);
   int n = scan.nextInt();
   int t1 = scan.nextInt();
   int t2 = scan.nextInt();
   int k = scan.nextInt();
   int a;
   int b;
   double[] result = new double[n];

   List<Gnome> Gnomes = new ArrayList<Gnome>();

   for (int i=0; i<n; i++){
       a=scan.nextInt();
       b=scan.nextInt();
       result[i]=mushroomHeight(t1,t2,k,a,b);
       if (result[i]<mushroomHeight(t1,t2,k,b,a)){
           result[i]=mushroomHeight(t1,t2,k,b,a);
       }
       Gnomes.add(new Gnome());
       Gnomes.add(new Gnome(i,result[i]));
   }
   Collections.sort(Gnomes);
   DecimalFormat df = new DecimalFormat("##.00");
   for(Gnome x: Gnomes)//printing the sorted list
   System.out.println(x.getGnomeNumber()+1 +" "+
     df.format(x.getGnomeResult()));
  // for (int i=0; i<result.length;i++)
  //     System.out.println(df.format(result[i]));
  }
}
  class Gnome implements Comparator<Gnome>, Comparable<Gnome>{
 private int number;
 private double result;
 Gnome(){
 }

 Gnome(int num, double res){
     number = num;
     result = res;
 }

 public int getGnomeNumber(){
    return number;
 }

 public double getGnomeResult(){
     return result;
 }

  public int compareTo(Gnome g){
      return ((this.result>g.result) ? -1:
              ((this.result)<g.result) ? 1:
              ((this.number<g.number)? -1:1));
   }
 public int compare(Gnome g1, Gnome g2){
      return ((g1.result>g2.result) ? -1:
              ((g1.result)<g2.result) ? 1:
              ((g1.number<g2.number)? -1:1));
   }
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ProblemB {

    static class Participant implements Comparable<Participant> {
        long m;
        int id;
        Participant(long _m, int i) {
            m = _m;
            id = i;
        }
        @Override
        public int compareTo(Participant arg0) {
            int r = Long.signum(arg0.m - m);
            if (r != 0) {
                return r;
            }
            return id - arg0.id;
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader s = new BufferedReader(new InputStreamReader(System.in));
        String[] data = s.readLine().split(" ");
        int n = Integer.valueOf(data[0]);
        long t1 = Integer.valueOf(data[1]);
        long t2 = Integer.valueOf(data[2]);
        long k = 100 - Integer.valueOf(data[3]);

        Participant[] p = new Participant[n];
        for (int i = 0 ; i < n ; i++) {
            String[] line = s.readLine().split(" ");
            long ai = Integer.valueOf(line[0]) * 100;
            long bi = Integer.valueOf(line[1]) * 100;

            long af = ai * t1 * k / 100 + bi * t2;
            long bf = bi * t1 * k / 100 + ai * t2;

            p[i] = new Participant(Math.max(af, bf), i+1);
        }
        Arrays.sort(p);

        for (int i = 0 ; i < n ; i++) {
            System.out.print(p[i].id + " ");

            long a = p[i].m / 100;
            long b = p[i].m % 100;
            if (b <= 9) {
                System.out.print(a + ".0" + b);
            } else {
                System.out.print(a + "." + b);
            }
            System.out.println();
        }
    }
}


import java.util.Arrays;
import java.util.Scanner;

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author mas1991
 */
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n =in.nextInt();
        int t1=in.nextInt();
        int t2=in.nextInt();
        double k=1.0-((double)in.nextInt()/100.0);
        dwarf d[]= new dwarf[n];
        for (int i = 1; i <= d.length; i++) {
            int v1=in.nextInt();
            int v2=in.nextInt();
            d[i-1]= new dwarf(i);
            d[i-1].score=Math.max(((double)v1*k*t1)+v2*t2, ((double)v2*k*t1)+v1*t2);
        }
        Arrays.sort(d);
        for (int i = 0; i < d.length; i++) {
            System.out.printf("%d %.2f\n",d[i].num,d[i].score);;

        }
    }
}
class dwarf implements Comparable<dwarf>
{
    int num;
    double score;

    public dwarf(int num) {
        this.num = num;

    }

    public int compareTo(dwarf o) {
        if(score>o.score)return -11;
        else if (score<o.score)return 1;
        else
        {
            return num-o.num;
        }
    }

}


import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Comparator;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.Writer;
import java.util.StringTokenizer;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 * @author lwc626
 */
public class Main {
	public static void main(String[] args) {
		InputStream inputStream = System.in;
		OutputStream outputStream = System.out;
		MyInputReader in = new MyInputReader(inputStream);
		MyOutputWriter out = new MyOutputWriter(outputStream);
		TaskB solver = new TaskB();
		solver.solve(1, in, out);
		out.close();
	}
}

class TaskB {
	public void solve(int testNumber, MyInputReader in, MyOutputWriter out) {
        int n = in.nextInt();
        int t1 = in.nextInt() ,t2 = in.nextInt() , k = in.nextInt() ;
        final int[] d = new int[n];
        for( int i = 0 ; i < n ; i++ ){
            int a = in.nextInt() , b = in.nextInt() ;
            d[i] = Math.max(get(a, b, t1, t2, k), get(b, a, t1, t2, k));
        }
        Integer[] order = ArrayUtils.order(n,new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                if( d[o1] != d[o2] )
                    return d[o1] > d[o2] ? -1 : 1;
                return o1 < o2 ? -1 : 1;
            }
        });
        for( Integer o : order ){
            String c = (new Integer(d[o]) ).toString();
            while ( c.length() <= 2) c = '0' + c;
            out.printLine( (o + 1)+ " " + c.substring( 0 , c.length()-2) + "." + c.substring( c.length()-2 ));

        }

	}

    private int get(int a, int b, int t1, int t2, int k) {
        return  a*t1*(100-k) + 100*b*t2;
    }
}

class MyInputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

    public MyInputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    }

class MyOutputWriter {
    private final PrintWriter writer;

    public MyOutputWriter(OutputStream outputStream) {
        writer = new PrintWriter(outputStream);
    }

    public MyOutputWriter(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 printLine(Object...objects) {
        print(objects);
        writer.println();
    }

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

}

class ArrayUtils {
    public static Integer[] generateOrder(int size){
        Integer[] order = new Integer[size];
        for( int i = 0 ; i < size ; i ++ ){
            order[i] = i ;
        }
        return order;
    }
    public static Integer[] order(int size, Comparator<Integer> comparator){
        Integer[] order = generateOrder( size );
        Arrays.sort(order, comparator);
        return order;
    }

}


import java.util.*;
import java.io.*;
import java.math.BigInteger;
import java.util.ArrayList;
public class Main{
    public static void main(String args[])throws Exception{
        BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(r);
        in.nextToken();
        int n = (int)in.nval;
        in.nextToken();
        int t1 = (int)in.nval;
        in.nextToken();
        int t2 = (int)in.nval;
        in.nextToken();
        int k = (int)in.nval;
        int a[][] = new int[n][2];
        for(int i=0;i<n;i++){
            in.nextToken();
            a[i][0] = (int)in.nval;
            in.nextToken();
            a[i][1] = (int)in.nval;
        }
        ArrayList<Cor> list = new ArrayList<Cor>();
        for(int i=0;i<n;i++){
            double max = Math.max((a[i][0]*t1*(100-k))/100.0+a[i][1]*t2,(a[i][1]*t1*(100-k))/100.0+a[i][0]*t2);
            list.add(new Cor(i + 1, max));
        }
        Collections.sort(list);
        for(int i=0;i<n;i++){
            System.out.print(list.get(i).x+" ");
            System.out.printf("%.2f", list.get(i).val);
            System.out.println();
        }
    }
}
class Cor implements Comparable<Cor>{
    int x;
    double val;
    public Cor(int x,double val){
        this.x=x;this.val=val;
    }

    public int compareTo(Cor o) {
        int a = (int)Math.round(o.val*100);
        int b = (int)Math.round(this.val*100);
        return a-b;
    }

}


import java.util.*;
import java.io.*;
import java.math.BigInteger;
public class Main{
    public static int MOD = 1000000007;
    public static void main(String args[])throws Exception{
        BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(r);
        in.nextToken();
        int n = (int)in.nval;
        in.nextToken();
        int t1 = (int)in.nval;
        in.nextToken();
        int t2 = (int)in.nval;
        in.nextToken();
        int k = (int)in.nval;
        int a[][] = new int[n][2];
        for(int i=0;i<n;i++){
            in.nextToken();
            a[i][0] = (int)in.nval;
            in.nextToken();
            a[i][1] = (int)in.nval;
        }
        double d[] = new double[n];
        for(int i=0;i<n;i++){
            double max = Math.max((a[i][0]*t1*(100-k))/100.0+a[i][1]*t2,(a[i][1]*t1*(100-k))/100.0+a[i][0]*t2);
            d[i] = max;
        }
        ArrayList<Cor> list = new ArrayList<Cor>();
        for(int i=0;i<n;i++){
            Cor cor = new Cor(i + 1, d[i]);
            list.add(cor);
        }
        Collections.sort(list);
        for(int i=n-1;i>=0;i--){
            System.out.print(list.get(i).x+" ");
            System.out.printf("%.2f\n",list.get(i).val);
        }
    }
    static class Cor implements Comparable<Cor>{
        int x;
        double val;
        public Cor(int x,double val){
            this.x=x;this.val=val;
        }
        public int compareTo(Cor o) {
            return (int)(this.val-o.val);
        }

    }

}


import java.util.*;
import java.io.*;
import java.math.BigInteger;
import java.util.ArrayList;
public class Main{
    public static void main(String args[])throws Exception{
        BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(r);
        in.nextToken();
        int n = (int)in.nval;
        in.nextToken();
        int t1 = (int)in.nval;
        in.nextToken();
        int t2 = (int)in.nval;
        in.nextToken();
        int k = (int)in.nval;
        int a[][] = new int[n][2];
        for(int i=0;i<n;i++){
            in.nextToken();
            a[i][0] = (int)in.nval;
            in.nextToken();
            a[i][1] = (int)in.nval;
        }
        ArrayList<Cor> list = new ArrayList<Cor>();
        for(int i=0;i<n;i++){
            double max = Math.max((a[i][0]*t1*(100-k))/100.0+a[i][1]*t2,(a[i][1]*t1*(100-k))/100.0+a[i][0]*t2);
            list.add(new Cor(i + 1, max));
        }
        Collections.sort(list);
        for(int i=0;i<n;i++){
            System.out.print(list.get(i).x+" ");
            System.out.printf("%.2f", list.get(i).val);
            System.out.println();
        }
    }
}
class Cor implements Comparable<Cor>{
    int x;
    double val;
    public Cor(int x,double val){
        this.x=x;this.val=val;
    }

    public int compareTo(Cor o) {
        return (int)(o.val-this.val);
    }

}


import java.util.*;
import java.io.*;
import java.math.BigInteger;
public class Main{
    public static int MOD = 1000000007;
    public static void main(String args[])throws Exception{
        BufferedReader r = new BufferedReader(new InputStreamReader(System.in));
        StreamTokenizer in = new StreamTokenizer(r);
        in.nextToken();
        int n = (int)in.nval;
        in.nextToken();
        int t1 = (int)in.nval;
        in.nextToken();
        int t2 = (int)in.nval;
        in.nextToken();
        int k = (int)in.nval;
        int a[][] = new int[n][2];
        for(int i=0;i<n;i++){
            in.nextToken();
            a[i][0] = (int)in.nval;
            in.nextToken();
            a[i][1] = (int)in.nval;
        }
        double d[] = new double[n];
        for(int i=0;i<n;i++){
            double max = Math.max((a[i][0]*t1*(100-k))/100.0+a[i][1]*t2,(a[i][1]*t1*(100-k))/100.0+a[i][0]*t2);
            d[i] = max;
        }
        ArrayList<Cor> list = new ArrayList<Cor>();
        for(int i=0;i<n;i++){
            Cor cor = new Cor(i + 1, d[i]);
            list.add(cor);
        }
        Collections.sort(list);
        for(int i=0;i<n;i++){
            System.out.print(list.get(i).x+" ");
            System.out.printf("%.2f\n",list.get(i).val);
        }
    }
    static class Cor implements Comparable<Cor>{
        int x;
        double val;
        public Cor(int x,double val){
            this.x=x;this.val=val;
        }
        public int compareTo(Cor o) {
            int a = (int)(Math.round(this.val*100)/100);
            int b = (int)(Math.round(o.val*100)/100);
            return b-a;
        }

    }

}


import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.util.*;
import java.util.Scanner;

public class B {

    public static void main( String[] argv){
        Scanner in = new Scanner ( System.in );

        while(in.hasNext()){
            int n=in.nextInt();int t1=in.nextInt();int t2=in.nextInt();int k=in.nextInt();
            ArrayList<Double> ar=new ArrayList<Double>();
            double[] arRef=new double[n];
            for(int i=1; i<=n; i++){
                int v1=in.nextInt(); int v2=in.nextInt();
                double res1=(double)(v1*t1)- (double)(v1*t1*k)/(double)100 + (double)(v2*t2);
                double res2=(double)(v2*t1)- (double)(v2*t1*k)/(double)100 + (double)(v1*t2);
                DecimalFormat df=new DecimalFormat(".00", new DecimalFormatSymbols(Locale.US));
                ar.add(Math.max(res1, res2));
                arRef[i-1]=Math.max(res1, res2);
          }

           Collections.sort(ar);
           DecimalFormat df=new DecimalFormat(".00", new DecimalFormatSymbols(Locale.US));

           boolean[] done=new boolean[n];
           for(int i=n-1; i>=0; i--){
               for(int j=0; j<n; j++){
                   if(arRef[j]==ar.get(i) & done[j]==false){
                       System.out.println((j+1)+" "+df.format(ar.get(i)));
                           done[j]=true;
                       }
                   }
        }

        }
    }
}


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Properties;

/**
 * Works good for CF
 * @author cykeltillsalu
 */
public class B118 {

	//some local config
	static boolean test = false;
	static String testDataFile = "testdata.txt";
	static String feedFile = "feed.txt";
	CompetitionType type = CompetitionType.CF;
	private static String ENDL = "\n";

	class Item implements Comparable<Item>{
		int id;
		BigDecimal value;
		public Item(int id, BigDecimal value) {
			super();
			this.id = id;
			this.value = value;
		}
		@Override
		public int compareTo(Item arg0) {
			int x = value.compareTo(arg0.value);
			if(x != 0){
				return x*-1;
			}
			return id - arg0.id;
		}
	}

	// solution
	private void solve() throws Throwable {

		double n = iread(), t1 = iread(), t2 = iread(), k = (1.0d - iread()/100.0);
		Item[] items = new Item[(int) n];
		for (int i = 0; i < n; i++) {
			double val = 0;

			double a = dread(), b = dread();
			val = Math.max(a*t1*k + b*t2, b*t1*k + a * t2);
			BigDecimal value = new BigDecimal(val).setScale(2, RoundingMode.HALF_UP);
			items[i] = new Item(i+1, value);
		}

		Arrays.sort(items);
		for (Item item : items) {
			out.write((item.id) + " " + item.value.toString() + ENDL);
		}
		out.flush();
	}

	public int iread() throws Exception {
		return Integer.parseInt(wread());
	}

	public double dread() throws Exception {
		return Double.parseDouble(wread());
	}

	public long lread() throws Exception {
		return Long.parseLong(wread());
	}

	public String wread() throws IOException {
		StringBuilder b = new StringBuilder();
		int c;
		c = in.read();
		while (c >= 0 && c <= ' ')
			c = in.read();
		if (c < 0)
			return "";
		while (c > ' ') {
			b.append((char) c);
			c = in.read();
		}
		return b.toString();
	}

	public static void main(String[] args) throws Throwable {

		if(test){ //run all cases from testfile:
			BufferedReader testdataReader = new BufferedReader(new FileReader(testDataFile));
			String readLine = testdataReader.readLine();
			int casenr = 0;
			out: while (true) {
				BufferedWriter w = new BufferedWriter(new FileWriter(feedFile));
				if(!readLine.equals("input")){
					break;
				}
				while (true) {
					readLine = testdataReader.readLine();
					if(readLine.equals("output")){
						break;
					}
					w.write(readLine + "\n");
				}
				w.close();
				System.out.println("Answer on case "+(++casenr)+": ");

				new B118().solve();
				System.out.println("Expected answer: ");

				while (true) {
					readLine = testdataReader.readLine();

					if(readLine == null){
						break out;
					}
					if(readLine.equals("input")){
						break;
					}
					System.out.println(readLine);
				}
				System.out.println("----------------");
			}
			testdataReader.close();
		} else { // run on server
			new B118().solve();
		}
		out.close();
	}

	public B118() throws Throwable {
		if (test) {
			in = new BufferedReader(new FileReader(new File(feedFile)));
		}
	}

	InputStreamReader inp = new InputStreamReader(System.in);
	BufferedReader in = new BufferedReader(inp);
	static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));

	enum CompetitionType {CF, OTHER};
}


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;
import java.util.Arrays;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Properties;

/**
 * Works good for CF
 * @author cykeltillsalu
 */
public class B118 {

	//some local config
	static boolean test = false;
	static String testDataFile = "testdata.txt";
	static String feedFile = "feed.txt";
	CompetitionType type = CompetitionType.CF;
	private static String ENDL = "\n";

	class Item implements Comparable<Item>{
		int id;
		BigDecimal value;
		public Item(int id, BigDecimal value) {
			super();
			this.id = id;
			this.value = value;
		}
		@Override
		public int compareTo(Item arg0) {
			int x = value.compareTo(arg0.value);
			if(x != 0){
				return x;
			}
			return id - arg0.id;
		}
	}

	// solution
	private void solve() throws Throwable {

		double n = iread(), t1 = iread(), t2 = iread(), k = (1.0d - iread()/100.0);
		Item[] items = new Item[(int) n];
		for (int i = 0; i < n; i++) {
			double val = 0;

			double a = dread(), b = dread();
			val = Math.max(a*t1*k + b*t2, b*t1*k + a * t2);
			BigDecimal value = new BigDecimal(val).setScale(2, RoundingMode.HALF_UP);
			items[i] = new Item(i+1, value);
		}

		Arrays.sort(items);
		for (Item item : items) {
			out.write((item.id) + " " + item.value.toString() + ENDL);
		}
		out.flush();
	}

	public int iread() throws Exception {
		return Integer.parseInt(wread());
	}

	public double dread() throws Exception {
		return Double.parseDouble(wread());
	}

	public long lread() throws Exception {
		return Long.parseLong(wread());
	}

	public String wread() throws IOException {
		StringBuilder b = new StringBuilder();
		int c;
		c = in.read();
		while (c >= 0 && c <= ' ')
			c = in.read();
		if (c < 0)
			return "";
		while (c > ' ') {
			b.append((char) c);
			c = in.read();
		}
		return b.toString();
	}

	public static void main(String[] args) throws Throwable {

		if(test){ //run all cases from testfile:
			BufferedReader testdataReader = new BufferedReader(new FileReader(testDataFile));
			String readLine = testdataReader.readLine();
			int casenr = 0;
			out: while (true) {
				BufferedWriter w = new BufferedWriter(new FileWriter(feedFile));
				if(!readLine.equals("input")){
					break;
				}
				while (true) {
					readLine = testdataReader.readLine();
					if(readLine.equals("output")){
						break;
					}
					w.write(readLine + "\n");
				}
				w.close();
				System.out.println("Answer on case "+(++casenr)+": ");

				new B118().solve();
				System.out.println("Expected answer: ");

				while (true) {
					readLine = testdataReader.readLine();

					if(readLine == null){
						break out;
					}
					if(readLine.equals("input")){
						break;
					}
					System.out.println(readLine);
				}
				System.out.println("----------------");
			}
			testdataReader.close();
		} else { // run on server
			new B118().solve();
		}
		out.close();
	}

	public B118() throws Throwable {
		if (test) {
			in = new BufferedReader(new FileReader(new File(feedFile)));
		}
	}

	InputStreamReader inp = new InputStreamReader(System.in);
	BufferedReader in = new BufferedReader(inp);
	static BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));

	enum CompetitionType {CF, OTHER};
}


import java.util.Scanner;

public class Mushroom{
	public static double maxLength(int first, int second, int k, int a, int b){
		double temp1 = (double) (a*first)*(1-(double)k/100) + (b*second);
		double temp2 = (double) (b*first)*(1-(double)k/100) + (a*second);

		return ( temp1 > temp2 ) ? temp1 : temp2;
	}

	public static void main(String[] args){
		Scanner stdIn = new Scanner(System.in);
		int n = stdIn.nextInt();
		int first = stdIn.nextInt();
		int second = stdIn.nextInt();
		int k = stdIn.nextInt();

		int[] a = new int[n];
		int[] b = new int[n];

		for(int i = 0; i < n; i++){
			a[i] = stdIn.nextInt();
			b[i] = stdIn.nextInt();
		}
		double[] result = new double[n];
		for(int i = 0; i < n; i++){
			result[i] = maxLength(first, second, k, a[i], b[i]);
		}

		for(int i = 0; i < n; i++){
			int max = 0;
			for(int j = 0; j < n; j++){
				if( result[j] > result[max] ){
					max = j;
				}
			}
			System.out.printf("%d %.2f%n", max+1, result[max]);
			result[max] = 0;
		}
	}
}


import java.io.*;
import java.util.*;

public class B
{
        String line;
        StringTokenizer inputParser;
        BufferedReader is;
        FileInputStream fstream;
        DataInputStream in;
        String FInput="";

        void openInput(String file)
        {

                if(file==null)is = new BufferedReader(new InputStreamReader(System.in));//stdin
                else
                {
                        try{

                        fstream = new FileInputStream(file);
                        in = new DataInputStream(fstream);
                        is = new BufferedReader(new InputStreamReader(in));
                        }catch(Exception e)
                        {
                                System.err.println(e);
                        }
                }

        }

        void readNextLine()
    	{
    		try {
    			line = is.readLine();
    			inputParser = new StringTokenizer(line, " ");
    			//System.err.println("Input: " + line);
    		} catch (IOException e) {
    			System.err.println("Unexpected IO ERROR: " + e);
    		}
    		catch (NullPointerException e)
    		{
    			line=null;

    		}

    	}

        long NextLong()
        {
                String n = inputParser.nextToken();

                long val = Long.parseLong(n);

                 return val;
        }

        int NextInt()
        {
                String n = inputParser.nextToken();
                int val = Integer.parseInt(n);

                //System.out.println("I read this number: " + val);
                return val;
        }

        String NextString()
        {
                String n = inputParser.nextToken();
                return n;
        }

        void closeInput()
        {
                try {
                        is.close();
                } catch (IOException e) {
                        System.err.println("Unexpected IO ERROR: " + e);
                }

        }

        public static void main(String [] argv)
        {
                String filePath=null;
                if(argv.length>0)filePath=argv[0];
                new B(filePath);
        }

        public void readFInput()
    	{
    		for(;;)
    		{
    			try
    			{
    				readNextLine();
    				FInput+=line+" ";
    			}
    			catch(Exception e)
    			{
    				break;
    			}
    		}
    		inputParser = new StringTokenizer(FInput, " ");
    	}

        public B(String inputFile)
        {
        	openInput(inputFile);
        	readNextLine();

    		int N=NextInt();
    		int t1=NextInt();
    		int t2=NextInt();
    		int K=NextInt();

    		C [] p = new C[N];
    		for(int i=0; i<N; i++)
    		{
    			readNextLine();
    			int a=NextInt();
    			int b=NextInt();
    			double fa=a*t1;
    			fa*=((100-K)/100.0);
    			fa+=b*t2;
    			double fb=b*t1;
    			fb*=((100-K)/100.0);
    			fb+=a*t2;
    			int resi=(int)(Math.max(fa, fb)*100);
    			p[i]=new C(i+1, resi);
    		}

    		Arrays.sort(p);

    		for(int i=0; i<N; i++)
    		{
    			String res=""+p[i].id+" "+getRes(p[i].resi);
    			System.out.println(res);
    		}

            closeInput();
    	}

        private String getRes(int resi) {
			String ret=""+resi/100.0;
			if(resi%10==0)ret+="0";
			//if(resi%100==0)ret+="0";
			return ret;
		}

		private class C implements Comparable<C>
        {
        	int resi, id;
        	C(int id, int resi)
        	{
        		this.id=id;
        		this.resi=resi;
        	}

        	public int compareTo( C d)
        	{
        		return d.resi - resi;
        	}
        }

}


import java.io.*;
import java.util.*;

public class B
{
        String line;
        StringTokenizer inputParser;
        BufferedReader is;
        FileInputStream fstream;
        DataInputStream in;
        String FInput="";

        void openInput(String file)
        {

                if(file==null)is = new BufferedReader(new InputStreamReader(System.in));//stdin
                else
                {
                        try{

                        fstream = new FileInputStream(file);
                        in = new DataInputStream(fstream);
                        is = new BufferedReader(new InputStreamReader(in));
                        }catch(Exception e)
                        {
                                System.err.println(e);
                        }
                }

        }

        void readNextLine()
    	{
    		try {
    			line = is.readLine();
    			inputParser = new StringTokenizer(line, " ");
    			//System.err.println("Input: " + line);
    		} catch (IOException e) {
    			System.err.println("Unexpected IO ERROR: " + e);
    		}
    		catch (NullPointerException e)
    		{
    			line=null;

    		}

    	}

        long NextLong()
        {
                String n = inputParser.nextToken();

                long val = Long.parseLong(n);

                 return val;
        }

        int NextInt()
        {
                String n = inputParser.nextToken();
                int val = Integer.parseInt(n);

                //System.out.println("I read this number: " + val);
                return val;
        }

        String NextString()
        {
                String n = inputParser.nextToken();
                return n;
        }

        void closeInput()
        {
                try {
                        is.close();
                } catch (IOException e) {
                        System.err.println("Unexpected IO ERROR: " + e);
                }

        }

        public static void main(String [] argv)
        {
                String filePath=null;
                if(argv.length>0)filePath=argv[0];
                new B(filePath);
        }

        public void readFInput()
    	{
    		for(;;)
    		{
    			try
    			{
    				readNextLine();
    				FInput+=line+" ";
    			}
    			catch(Exception e)
    			{
    				break;
    			}
    		}
    		inputParser = new StringTokenizer(FInput, " ");
    	}

        public B(String inputFile)
        {
        	openInput(inputFile);
        	readNextLine();

    		int N=NextInt();
    		int t1=NextInt();
    		int t2=NextInt();
    		int K=NextInt();

    		int [] a, b;
    		a = new int [N];
    		b = new int [N];
    		double [] f = new double[N];

    		C [] p = new C[N];
    		for(int i=0; i<N; i++)
    		{
    			readNextLine();
    			a[i]=NextInt();
    			b[i]=NextInt();
    			if(a[i]>b[i])
    			{
    				int t=a[i];
    				a[i]=b[i];
    				b[i]=t;
    			}
    			f[i]=a[i]*t1;
    			f[i]*=((100-K)/100.0);
    			f[i]+=b[i]*t2;
    			int resi=(int)(f[i]*100);
    			p[i]=new C(i+1, resi);
    		}

    		Arrays.sort(p);

    		for(int i=0; i<N; i++)
    		{
    			String res=""+p[i].id+" "+(p[i].resi/100.0);
    			System.out.println(res);
    		}

            closeInput();
    	}

        private class C implements Comparable<C>
        {
        	int resi, id;
        	C(int id, int resi)
        	{
        		this.id=id;
        		this.resi=resi;
        	}

        	public int compareTo( C d)
        	{
        		return d.resi - resi;
        	}
        }

}


import java.io.*;
import java.util.*;

public class B
{
        String line;
        StringTokenizer inputParser;
        BufferedReader is;
        FileInputStream fstream;
        DataInputStream in;
        String FInput="";

        void openInput(String file)
        {

                if(file==null)is = new BufferedReader(new InputStreamReader(System.in));//stdin
                else
                {
                        try{

                        fstream = new FileInputStream(file);
                        in = new DataInputStream(fstream);
                        is = new BufferedReader(new InputStreamReader(in));
                        }catch(Exception e)
                        {
                                System.err.println(e);
                        }
                }

        }

        void readNextLine()
    	{
    		try {
    			line = is.readLine();
    			inputParser = new StringTokenizer(line, " ");
    			//System.err.println("Input: " + line);
    		} catch (IOException e) {
    			System.err.println("Unexpected IO ERROR: " + e);
    		}
    		catch (NullPointerException e)
    		{
    			line=null;

    		}

    	}

        long NextLong()
        {
                String n = inputParser.nextToken();

                long val = Long.parseLong(n);

                 return val;
        }

        int NextInt()
        {
                String n = inputParser.nextToken();
                int val = Integer.parseInt(n);

                //System.out.println("I read this number: " + val);
                return val;
        }

        String NextString()
        {
                String n = inputParser.nextToken();
                return n;
        }

        void closeInput()
        {
                try {
                        is.close();
                } catch (IOException e) {
                        System.err.println("Unexpected IO ERROR: " + e);
                }

        }

        public static void main(String [] argv)
        {
                String filePath=null;
                if(argv.length>0)filePath=argv[0];
                new B(filePath);
        }

        public void readFInput()
    	{
    		for(;;)
    		{
    			try
    			{
    				readNextLine();
    				FInput+=line+" ";
    			}
    			catch(Exception e)
    			{
    				break;
    			}
    		}
    		inputParser = new StringTokenizer(FInput, " ");
    	}

        public B(String inputFile)
        {
        	openInput(inputFile);
        	readNextLine();

    		int N=NextInt();
    		int t1=NextInt();
    		int t2=NextInt();
    		int K=NextInt();

    		int [] a, b;
    		a = new int [N];
    		b = new int [N];
    		double [] f = new double[N];

    		C [] p = new C[N];
    		for(int i=0; i<N; i++)
    		{
    			readNextLine();
    			a[i]=NextInt();
    			b[i]=NextInt();
    			if(a[i]>b[i])
    			{
    				int t=a[i];
    				a[i]=b[i];
    				b[i]=t;
    			}
    			f[i]=a[i]*t1;
    			f[i]*=((100-K)/100.0);
    			f[i]+=b[i]*t2;
    			int resi=(int)(f[i]*100);
    			p[i]=new C(i+1, resi);
    		}

    		Arrays.sort(p);

    		for(int i=0; i<N; i++)
    		{
    			String res=""+p[i].id+" "+getRes(p[i].resi);
    			System.out.println(res);
    		}

            closeInput();
    	}

        private String getRes(int resi) {
			String ret=""+resi/100.0;
			if(resi%10==0)ret+="0";
			//if(resi%100==0)ret+="0";
			return ret;
		}

		private class C implements Comparable<C>
        {
        	int resi, id;
        	C(int id, int resi)
        	{
        		this.id=id;
        		this.resi=resi;
        	}

        	public int compareTo( C d)
        	{
        		return d.resi - resi;
        	}
        }

}


import java.io.*;
import java.util.*;

public class B
{
        String line;
        StringTokenizer inputParser;
        BufferedReader is;
        FileInputStream fstream;
        DataInputStream in;
        String FInput="";

        void openInput(String file)
        {

                if(file==null)is = new BufferedReader(new InputStreamReader(System.in));//stdin
                else
                {
                        try{

                        fstream = new FileInputStream(file);
                        in = new DataInputStream(fstream);
                        is = new BufferedReader(new InputStreamReader(in));
                        }catch(Exception e)
                        {
                                System.err.println(e);
                        }
                }

        }

        void readNextLine()
    	{
    		try {
    			line = is.readLine();
    			inputParser = new StringTokenizer(line, " ");
    			//System.err.println("Input: " + line);
    		} catch (IOException e) {
    			System.err.println("Unexpected IO ERROR: " + e);
    		}
    		catch (NullPointerException e)
    		{
    			line=null;

    		}

    	}

        long NextLong()
        {
                String n = inputParser.nextToken();

                long val = Long.parseLong(n);

                 return val;
        }

        int NextInt()
        {
                String n = inputParser.nextToken();
                int val = Integer.parseInt(n);

                //System.out.println("I read this number: " + val);
                return val;
        }

        String NextString()
        {
                String n = inputParser.nextToken();
                return n;
        }

        void closeInput()
        {
                try {
                        is.close();
                } catch (IOException e) {
                        System.err.println("Unexpected IO ERROR: " + e);
                }

        }

        public static void main(String [] argv)
        {
                String filePath=null;
                if(argv.length>0)filePath=argv[0];
                new B(filePath);
        }

        public void readFInput()
    	{
    		for(;;)
    		{
    			try
    			{
    				readNextLine();
    				FInput+=line+" ";
    			}
    			catch(Exception e)
    			{
    				break;
    			}
    		}
    		inputParser = new StringTokenizer(FInput, " ");
    	}

        public B(String inputFile)
        {
        	openInput(inputFile);
        	readNextLine();

    		int N=NextInt();
    		int t1=NextInt();
    		int t2=NextInt();
    		int K=NextInt();

    		C [] p = new C[N];
    		for(int i=0; i<N; i++)
    		{
    			readNextLine();
    			int a=NextInt();
    			int b=NextInt();
    			double fa=a*t1;
    			fa*=((100-K)/100.0);
    			fa+=b*t2;
    			double fb=b*t1;
    			fb*=((100-K)/100.0);
    			fb+=a*t2;
    			int resi=(int)Math.round(Math.max(fa, fb)*100);
    			p[i]=new C(i+1, resi);
    		}

    		Arrays.sort(p);

    		for(int i=0; i<N; i++)
    		{
    			String res=""+p[i].id+" "+getRes(p[i].resi);
    			System.out.println(res);
    		}

            closeInput();
    	}

        private String getRes(int resi) {
			String ret=""+resi/100.0;
			if(resi%10==0)ret+="0";
			//if(resi%100==0)ret+="0";
			return ret;
		}

		private class C implements Comparable<C>
        {
        	int resi, id;
        	C(int id, int resi)
        	{
        		this.id=id;
        		this.resi=resi;
        	}

        	public int compareTo( C d)
        	{
        		return d.resi - resi;
        	}
        }

}


import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;

public class B {

        final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE")!=null;
        BufferedReader in;
        PrintWriter out;
        StringTokenizer tok = new StringTokenizer("");

        void init() throws FileNotFoundException{
                if (ONLINE_JUDGE){
                        in = new BufferedReader(new InputStreamReader(System.in));
                        out = new PrintWriter(System.out);
                }else{
                        in = new BufferedReader(new FileReader("input.txt"));
                        out = new PrintWriter("output.txt");
                }
        }

        String readString() throws IOException{
                while(!tok.hasMoreTokens()){
                        tok = new StringTokenizer(in.readLine());
                }
                return tok.nextToken();
        }

        int readInt() throws IOException{
                return Integer.parseInt(readString());
        }

        long readLong() throws IOException{
                return Long.parseLong(readString());
        }

        double readDouble() throws IOException{
                return Double.parseDouble(readString());
        }

        int[] readArr(int n) throws IOException{
        	int[] res = new int[n];
        	for(int i = 0; i < n; i++){
        		res[i] = readInt();
        	}
        	return res;
        }

        long[] readArrL(int n) throws IOException{
        	long[] res = new long[n];
        	for(int i = 0; i < n; i++){
        		res[i] = readLong();
        	}
        	return res;
        }

        public static void main(String[] args){
                new B().run();
        }

        public void run(){
                try{
                        long t1 = System.currentTimeMillis();
                        init();
                        solve();
                        out.close();
                        long t2 = System.currentTimeMillis();
                        System.err.println("Time = "+(t2-t1));
                }catch (Exception e){
                        e.printStackTrace(System.err);
                        System.exit(-1);
                }
        }

        class pnt implements Comparable<pnt>{

        	long r;
        	int i;

			@Override
			public int compareTo(pnt o) {
				if(this.r > o.r) return -1;
				if(this.r < o.r) return 1;
				return this.i - o.i;
			}

			public pnt(long r, int i) {
				super();
				this.r = r;
				this.i = i;
			}

        }

        void solve() throws IOException{
        	int n = readInt();
        	int t1 = readInt();
        	int t2 = readInt();
        	int k = readInt();
        	long[] a = new long[n];
        	long[] b = new long[n];
        	for(int i = 0; i < n; i++){
        		a[i] = readInt()*100;
        		b[i] = readInt()*100;
        	}
        	pnt[] res = new pnt[n];
        	for(int i = 0; i < n; i++){
        		long cur = (a[i]*t1)*(100-k)/100 + b[i]*t2;
        		cur = max(cur, (b[i]*t1)*(100-k)/100 + a[i]*t2);
        		res[i] = new pnt(cur, i+1);
        	}
        	Arrays.sort(res);
        	for(int i = 0; i < n-1; i++){
        		out.print(res[i].i + " ");
        		out.println(res[i].r/100+"."+(res[i].r%100/10)+""+res[i].r%10);
        	}
        	int i = n-1;
        	out.print(res[i].i + " ");
    		out.print((int)(res[i].r/100)+"."+(int)(res[i].r%100/10)+""+(int)(res[i].r%10));
        }

        void maxHepify(int[] a, int i, int length){
        	int l = (i<<1) + 1;
        	int r = (i<<1) + 2;
        	int largest = i;
        	if(l < length && a[l] > a[largest])
        		largest = l;
        	if(r < length && a[r] > a[largest])
        		largest = r;
        	if(largest != i){
        		a[largest] += a[i];
        		a[i] = a[largest] - a[i];
        		a[largest] -= a[i];
        		maxHepify(a, largest, length);
        	}
        }

        void buildMaxHeap(int[] a){
        	for(int i = a.length/2 - 1; i >= 0; i--){
        		maxHepify(a, i, a.length);
        	}
        }

        void heapSort(int[] a){
        	buildMaxHeap(a);
        	for(int i = a.length - 1; i > 0; i--){
        		a[i] += a[0];
        		a[0] = a[i] - a[0];
        		a[i] -= a[0];
        		maxHepify(a, 0, i);
        	}
        }

        int[] zFunction(char[] s){
        	int[] z = new int[s.length];
        	z[0] = 0;
        	for (int i=1, l=0, r=0; i<s.length; ++i) {
        		if (i <= r)
        			z[i] = min (r-i+1, z[i-l]);
        		while (i+z[i] < s.length && s[z[i]] == s[i+z[i]])
        			++z[i];
        		if (i+z[i]-1 > r){
        			l = i;
        			r = i+z[i]-1;
        		}
        	}
        	return z;
        }

        int[] prefixFunction(char[] s){
        	int[] pr = new int[s.length];
        	for (int i = 1; i< s.length; ++i) {
        		int j = pr[i-1];
        		while (j > 0 && s[i] != s[j])
        			j = pr[j-1];
        		if (s[i] == s[j])  ++j;
        		pr[i] = j;
        	}
        	return pr;
        }

        int ModExp(int a, int n, int mod){
        	int res = 1;
        	while (n!=0)
        		if ((n & 1) != 0) {
        			res = (res*a)%mod;
        			--n;
        		}
        		else {
        			a = (a*a)%mod;
        			n >>= 1;
        		}
        	return res;
        }

        public static class Utils {

        	private Utils() {}

        	public static void mergeSort(int[] a) {
                    mergeSort(a, 0, a.length - 1);
            }

        	private static void mergeSort(int[] a, int leftIndex, int rightIndex) {
                    final int MAGIC_VALUE = 50;
                    if (leftIndex < rightIndex) {
                            if (rightIndex - leftIndex <= MAGIC_VALUE) {
                                    insertionSort(a, leftIndex, rightIndex);
                            } else {
                                    int middleIndex = (leftIndex + rightIndex) / 2;
                                    mergeSort(a, leftIndex, middleIndex);
                                    mergeSort(a, middleIndex + 1, rightIndex);
                                    merge(a, leftIndex, middleIndex, rightIndex);
                            }
                    }
            }

            private static void merge(int[] a, int leftIndex, int middleIndex, int rightIndex) {
            	int length1 = middleIndex - leftIndex + 1;
            	int length2 = rightIndex - middleIndex;
                int[] leftArray = new int[length1];
                int[] rightArray = new int[length2];
                System.arraycopy(a, leftIndex, leftArray, 0, length1);
                System.arraycopy(a, middleIndex + 1, rightArray, 0, length2);
                for (int k = leftIndex, i = 0, j = 0; k <= rightIndex; k++) {
                    if (i == length1) {
                            a[k] = rightArray[j++];
                    } else if (j == length2) {
                            a[k] = leftArray[i++];
                    } else {
                            a[k] = leftArray[i] <= rightArray[j] ? leftArray[i++] : rightArray[j++];
                    }
                }
            }

            private static void insertionSort(int[] a, int leftIndex, int rightIndex) {
                for (int i = leftIndex + 1; i <= rightIndex; i++) {
            		int current = a[i];
                    int j = i - 1;
                	while (j >= leftIndex && a[j] > current) {
                        a[j + 1] = a[j];
                        j--;
                        }
                    a[j + 1] = current;
                }
            }
        }

        boolean isPrime(int a){
        	for(int i = 2; i <= sqrt(a); i++)
        		if(a % i == 0) return false;
        	return true;
        }

        static double distance(long x1, long y1, long x2, long y2){
        	return Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
        }

        static long gcd(long a, long b){
        	if(min(a,b) == 0) return max(a,b);
        	return gcd(max(a, b) % min(a,b), min(a,b));
        }

        static long lcm(long a, long b){
        	return a * b /gcd(a, b);
        }
}

/*class Treap<K extends Comparable<K>>{

	public K x;
	public double y;
	public Treap<K> left;
	public Treap<K> right;

	public Treap(K x, double y, Treap<K> left, Treap<K> right) {
		this.x = x;
		this.y = y;
		this.left = left;
		this.right = right;
	}

	public static <K extends Comparable<K>> Treap<K> merge(Treap<K> l, Treap<K> r){
		if(l == null) return r;
		if(r == null) return l;
		if(l.y > r.y){
			return new Treap<K>(l.x, l.y, l.left, merge(l.right, r));
		}
		else{
			return new Treap<K>(r.x, r.y, merge(l, r.left), r.right);
		}
	}

	public void split(K x, Treap<K> left, Treap<K> right){
		Treap<K> newTreap = null;
		if(this.x.compareTo(x) <= 0){
			if(this.right == null){
				right = null;
			}
			else{
				right.split(x, newTreap, right);
			}
			left = new Treap<K>(this.x, this.y, left, newTreap);
		}
		else{
			if(this.left == null){
				left = null;
			}
			else{
				left.split(x, left, newTreap);
			}
			right = new Treap<K>(x, y, newTreap, right);
		}
	}

	public Treap<K> add(K x){
		Treap<K> left = null, right = null;
		this.split(x, left, right);
		Treap<K> temp = new Treap<K>(x, random(), null, null);
		return merge(merge(left, temp), right);
	}

	@SuppressWarnings("null")
	public Treap<K> remove(K x){
		Treap<K> left = null, temp = null, right = null;
		this.split(x, left, right);
		right.split(x, temp, right);
		return merge(left, right);
	}

	public static <K extends Comparable<K>> Treap<K> build(K[] a){
		Treap<K> temp = new Treap<K>(a[0], random(), null, null);
		for(int i = 1; i < a.length; i++){
			temp = temp.add(a[i]);
		}
		return temp;
	}
}*/


import java.awt.Point;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;

public class B {

        final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE")!=null;
        BufferedReader in;
        PrintWriter out;
        StringTokenizer tok = new StringTokenizer("");

        void init() throws FileNotFoundException{
                if (ONLINE_JUDGE){
                        in = new BufferedReader(new InputStreamReader(System.in));
                        out = new PrintWriter(System.out);
                }else{
                        in = new BufferedReader(new FileReader("input.txt"));
                        out = new PrintWriter("output.txt");
                }
        }

        String readString() throws IOException{
                while(!tok.hasMoreTokens()){
                        tok = new StringTokenizer(in.readLine());
                }
                return tok.nextToken();
        }

        int readInt() throws IOException{
                return Integer.parseInt(readString());
        }

        long readLong() throws IOException{
                return Long.parseLong(readString());
        }

        double readDouble() throws IOException{
                return Double.parseDouble(readString());
        }

        int[] readArr(int n) throws IOException{
        	int[] res = new int[n];
        	for(int i = 0; i < n; i++){
        		res[i] = readInt();
        	}
        	return res;
        }

        long[] readArrL(int n) throws IOException{
        	long[] res = new long[n];
        	for(int i = 0; i < n; i++){
        		res[i] = readLong();
        	}
        	return res;
        }

        public static void main(String[] args){
                new B().run();
        }

        public void run(){
                try{
                        long t1 = System.currentTimeMillis();
                        init();
                        solve();
                        out.close();
                        long t2 = System.currentTimeMillis();
                        System.err.println("Time = "+(t2-t1));
                }catch (Exception e){
                        e.printStackTrace(System.err);
                        System.exit(-1);
                }
        }

        class pnt implements Comparable<pnt>{

        	long r;
        	int i;

			@Override
			public int compareTo(pnt o) {
				if(this.r > o.r) return -1;
				return 1;
			}

			public pnt(long r, int i) {
				super();
				this.r = r;
				this.i = i;
			}

        }

        void solve() throws IOException{
        	int n = readInt();
        	int t1 = readInt();
        	int t2 = readInt();
        	int k = readInt();
        	long[] a = new long[n];
        	long[] b = new long[n];
        	for(int i = 0; i < n; i++){
        		a[i] = readInt()*100;
        		b[i] = readInt()*100;
        	}
        	pnt[] res = new pnt[n];
        	for(int i = 0; i < n; i++){
        		long cur = (a[i]*t1)*(100-k)/100 + b[i]*t2;
        		cur = max(cur, (b[i]*t1)*(100-k)/100 + a[i]*t2);
        		res[i] = new pnt(cur, i+1);
        	}
        	Arrays.sort(res);
        	for(int i = 0; i < n-1; i++){
        		out.print(res[i].i + " ");
        		out.println(res[i].r/100+"."+(res[i].r%100/10)+""+res[i].r%10);
        	}
        	int i = n-1;
        	out.print(res[i].i + " ");
    		out.print(res[i].r/100+"."+(res[i].r%100/10)+""+res[i].r%10);
        }

        void maxHepify(int[] a, int i, int length){
        	int l = (i<<1) + 1;
        	int r = (i<<1) + 2;
        	int largest = i;
        	if(l < length && a[l] > a[largest])
        		largest = l;
        	if(r < length && a[r] > a[largest])
        		largest = r;
        	if(largest != i){
        		a[largest] += a[i];
        		a[i] = a[largest] - a[i];
        		a[largest] -= a[i];
        		maxHepify(a, largest, length);
        	}
        }

        void buildMaxHeap(int[] a){
        	for(int i = a.length/2 - 1; i >= 0; i--){
        		maxHepify(a, i, a.length);
        	}
        }

        void heapSort(int[] a){
        	buildMaxHeap(a);
        	for(int i = a.length - 1; i > 0; i--){
        		a[i] += a[0];
        		a[0] = a[i] - a[0];
        		a[i] -= a[0];
        		maxHepify(a, 0, i);
        	}
        }

        int[] zFunction(char[] s){
        	int[] z = new int[s.length];
        	z[0] = 0;
        	for (int i=1, l=0, r=0; i<s.length; ++i) {
        		if (i <= r)
        			z[i] = min (r-i+1, z[i-l]);
        		while (i+z[i] < s.length && s[z[i]] == s[i+z[i]])
        			++z[i];
        		if (i+z[i]-1 > r){
        			l = i;
        			r = i+z[i]-1;
        		}
        	}
        	return z;
        }

        int[] prefixFunction(char[] s){
        	int[] pr = new int[s.length];
        	for (int i = 1; i< s.length; ++i) {
        		int j = pr[i-1];
        		while (j > 0 && s[i] != s[j])
        			j = pr[j-1];
        		if (s[i] == s[j])  ++j;
        		pr[i] = j;
        	}
        	return pr;
        }

        int ModExp(int a, int n, int mod){
        	int res = 1;
        	while (n!=0)
        		if ((n & 1) != 0) {
        			res = (res*a)%mod;
        			--n;
        		}
        		else {
        			a = (a*a)%mod;
        			n >>= 1;
        		}
        	return res;
        }

        public static class Utils {

        	private Utils() {}

        	public static void mergeSort(int[] a) {
                    mergeSort(a, 0, a.length - 1);
            }

        	private static void mergeSort(int[] a, int leftIndex, int rightIndex) {
                    final int MAGIC_VALUE = 50;
                    if (leftIndex < rightIndex) {
                            if (rightIndex - leftIndex <= MAGIC_VALUE) {
                                    insertionSort(a, leftIndex, rightIndex);
                            } else {
                                    int middleIndex = (leftIndex + rightIndex) / 2;
                                    mergeSort(a, leftIndex, middleIndex);
                                    mergeSort(a, middleIndex + 1, rightIndex);
                                    merge(a, leftIndex, middleIndex, rightIndex);
                            }
                    }
            }

            private static void merge(int[] a, int leftIndex, int middleIndex, int rightIndex) {
            	int length1 = middleIndex - leftIndex + 1;
            	int length2 = rightIndex - middleIndex;
                int[] leftArray = new int[length1];
                int[] rightArray = new int[length2];
                System.arraycopy(a, leftIndex, leftArray, 0, length1);
                System.arraycopy(a, middleIndex + 1, rightArray, 0, length2);
                for (int k = leftIndex, i = 0, j = 0; k <= rightIndex; k++) {
                    if (i == length1) {
                            a[k] = rightArray[j++];
                    } else if (j == length2) {
                            a[k] = leftArray[i++];
                    } else {
                            a[k] = leftArray[i] <= rightArray[j] ? leftArray[i++] : rightArray[j++];
                    }
                }
            }

            private static void insertionSort(int[] a, int leftIndex, int rightIndex) {
                for (int i = leftIndex + 1; i <= rightIndex; i++) {
            		int current = a[i];
                    int j = i - 1;
                	while (j >= leftIndex && a[j] > current) {
                        a[j + 1] = a[j];
                        j--;
                        }
                    a[j + 1] = current;
                }
            }
        }

        boolean isPrime(int a){
        	for(int i = 2; i <= sqrt(a); i++)
        		if(a % i == 0) return false;
        	return true;
        }

        static double distance(long x1, long y1, long x2, long y2){
        	return Math.sqrt((x1-x2)*(x1-x2)+(y1-y2)*(y1-y2));
        }

        static long gcd(long a, long b){
        	if(min(a,b) == 0) return max(a,b);
        	return gcd(max(a, b) % min(a,b), min(a,b));
        }

        static long lcm(long a, long b){
        	return a * b /gcd(a, b);
        }
}

/*class Treap<K extends Comparable<K>>{

	public K x;
	public double y;
	public Treap<K> left;
	public Treap<K> right;

	public Treap(K x, double y, Treap<K> left, Treap<K> right) {
		this.x = x;
		this.y = y;
		this.left = left;
		this.right = right;
	}

	public static <K extends Comparable<K>> Treap<K> merge(Treap<K> l, Treap<K> r){
		if(l == null) return r;
		if(r == null) return l;
		if(l.y > r.y){
			return new Treap<K>(l.x, l.y, l.left, merge(l.right, r));
		}
		else{
			return new Treap<K>(r.x, r.y, merge(l, r.left), r.right);
		}
	}

	public void split(K x, Treap<K> left, Treap<K> right){
		Treap<K> newTreap = null;
		if(this.x.compareTo(x) <= 0){
			if(this.right == null){
				right = null;
			}
			else{
				right.split(x, newTreap, right);
			}
			left = new Treap<K>(this.x, this.y, left, newTreap);
		}
		else{
			if(this.left == null){
				left = null;
			}
			else{
				left.split(x, left, newTreap);
			}
			right = new Treap<K>(x, y, newTreap, right);
		}
	}

	public Treap<K> add(K x){
		Treap<K> left = null, right = null;
		this.split(x, left, right);
		Treap<K> temp = new Treap<K>(x, random(), null, null);
		return merge(merge(left, temp), right);
	}

	@SuppressWarnings("null")
	public Treap<K> remove(K x){
		Treap<K> left = null, temp = null, right = null;
		this.split(x, left, right);
		right.split(x, temp, right);
		return merge(left, right);
	}

	public static <K extends Comparable<K>> Treap<K> build(K[] a){
		Treap<K> temp = new Treap<K>(a[0], random(), null, null);
		for(int i = 1; i < a.length; i++){
			temp = temp.add(a[i]);
		}
		return temp;
	}
}*/