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

import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.System.*;

public class B {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        StringTokenizer st = new StringTokenizer(in.readLine());
        int n = parseInt(st.nextToken()), m = parseInt(st.nextToken());
        int Sx = parseInt(st.nextToken()), Sy = parseInt(st.nextToken());

        solve(n, m, Sx, Sy, pw);

        pw.close();
    }

    static void solve(int n, int m, int sx, int sy, PrintWriter pw) {
        HashMap<String, Boolean> exist = new HashMap<>();
        String s = sx + "" + sy;
        exist.put(s, true);
        pw.println(sx + " " + sy);
        s = 1 + "" + sy;
        exist.put(s, true);
        pw.println(1 + " " + sy);
        s = 1 + "" + 1;
        exist.put(s, true);
        pw.println(1 + " " + 1);
        int x = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (i % 2 != 0) {
                    s = i + "" + j;
                    if (x >= 3  || !exist.getOrDefault(s, false)) {
                        pw.println(i + " " + j);
                    }
                } else {
                    s = i + "" + (m - j + 1);
                    if (x >= 3 || !exist.getOrDefault(s, false)) {
                        pw.println(i + " " + (m - j + 1));
                    }
                }
            }
        }
       // pw.println(x);
    }
}


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

import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.System.*;

public class B {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        StringTokenizer st = new StringTokenizer(in.readLine());
        int n = parseInt(st.nextToken()), m = parseInt(st.nextToken());
        int Sx = parseInt(st.nextToken()), Sy = parseInt(st.nextToken());

        pw.println(solve(n, m, Sx, Sy));

        pw.close();
    }

    static StringBuilder solve(int n, int m, int sx, int sy) {
        HashMap<String, Boolean> exist = new HashMap<>();
        StringBuilder sb = new StringBuilder();
        String s = sx + "" + sy;
        exist.put(s, true);
        sb.append(sx + " " + sy + "\n");
        s = 1 + "" + sy;
        exist.put(s, true);
        sb.append(1 + " " + sy + "\n");
        s = 1 + "" + 1;
        exist.put(s, true);
        sb.append(1 + " " + 1 + "\n");
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (i % 2 != 0) {
                    s = i + "" + j;
                    if (!exist.getOrDefault(s, false)) {
                        sb.append(i + " " + j + "\n");
                        exist.put(s, true);
                    }
                } else {
                    s = i + "" + (m - j + 1);
                    if (!exist.getOrDefault(s, false)) {
                        sb.append(i + " " + (m - j + 1) + "\n");
                        exist.put(s, true);
                    }
                }
            }
        }
        //sb.delete(sb.length() - 1, sb.length());
        return sb;
    }
}


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

import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.System.*;

public class B {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        StringTokenizer st = new StringTokenizer(in.readLine());
        int n = parseInt(st.nextToken()), m = parseInt(st.nextToken());
        int Sx = parseInt(st.nextToken()), Sy = parseInt(st.nextToken());

        pw.print(solve(n, m, Sx, Sy));

        pw.close();
    }

    static StringBuilder solve(int n, int m, int sx, int sy) {
        HashMap<String, Boolean> exist = new HashMap<>();
        StringBuilder sb = new StringBuilder();
        String s = sx + "" + sy;
        exist.put(s, true);
        sb.append(sx + " " + sy + "\n");
        s = 1 + "" + sy;
        exist.put(s, true);
        sb.append(1 + " " + sy + "\n");
        s = 1 + "" + 1;
        exist.put(s, true);
        sb.append(1 + " " + 1 + "\n");
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (i % 2 != 0) {
                    s = i + "" + j;
                    if (!exist.getOrDefault(s, false)) {
                        sb.append(i + " " + j + "\n");
                        exist.put(s, true);
                    }
                } else {
                    s = i + "" + (m - j + 1);
                    if (!exist.getOrDefault(s, false)) {
                        sb.append(i + " " + (m - j + 1) + "\n");
                        exist.put(s, true);
                    }
                }
            }
        }
        sb.delete(sb.length() - 1, sb.length());
        return sb;
    }
}


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

import static java.lang.Integer.*;
import static java.lang.Long.*;
import static java.lang.System.*;

public class B {
    public static void main(String[] args) throws IOException {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw = new PrintWriter(System.out);
        StringTokenizer st = new StringTokenizer(in.readLine());
        int n = parseInt(st.nextToken()), m = parseInt(st.nextToken());
        int Sx = parseInt(st.nextToken()), Sy = parseInt(st.nextToken());

        solve(n, m, Sx, Sy, pw);

        pw.close();
    }

    static void solve(int n, int m, int sx, int sy, PrintWriter pw) {
        pw.println(sx + " " + sy);
        pw.println(1 + " " + sy);
        pw.println(1 + " " + 1);
        int x = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                if (i % 2 != 0) {
                    if (i == sx && j == sy) continue;
                    if (i == 1 && j == sy) continue;
                    if (i == 1 && j == 1) continue;
                    pw.println(i + " " + j);

                } else {
                    if (i == sx && (m - j + 1) == sy) continue;
                    if (i == 1 && (m - j + 1) == sy) continue;
                    if (i == 1 && (m - j + 1) == 1) continue;
                    pw.println(i + " " + (m - j + 1));
                }
            }
        }
    }
}


import java.util.*;
import java.lang.*;
import java.math.*;
import java.awt.Checkbox;
import java.awt.image.ConvolveOp;
import java.io.*;
import java.text.DecimalFormat;
import java.lang.reflect.Array;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.util.*;
public class Codeforces{
	public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
	static long MOD = (long)(1e9+7);
	//static long MOD = 998244353;
	static FastReader sc = new FastReader();
	static int pInf = Integer.MAX_VALUE;
	static int nInf = Integer.MIN_VALUE;
	public static void main(String[] args){
		int test = 1;
		//test = sc.nextInt();
		while(test-->0){
			int n = sc.nextInt();
			int m = sc.nextInt();
			int x = sc.nextInt();
			int y = sc.nextInt();
			for(int i = x; i >= 1; i--) {
				out.println(y+" "+i);
			}
			for(int i = x+1; i <= m; i++) {
				out.println(y+" "+i);
			}
			int c = 0;
			for(int i = y+1; i <= n; i++) {
				if(c==0) {
					c=1;
					for(int j = m; j >= 1; j--) {
						out.println(i+" "+j);
					}
				}
				else {
					c=0;
					for(int j = 1; j <= m; j++) {
						out.println(i+" "+j);
					}
				}
			}
			for(int i = y-1; i >= 1; i--) {
				if(c==0) {
					c=1;
					for(int j = m; j >= 1; j--) {
						out.println(i+" "+j);
					}
				}
				else {
					c=0;
					for(int j = 1; j <= m; j++) {
						out.println(i+" "+j);
					}
				}
			}
  		}
		out.close();
	}
	public static long mul(long a, long b){
	    return ((a%MOD)*(b%MOD))%MOD;
	}
	public static long add(long a, long b){
	    return ((a%MOD)+(b%MOD))%MOD;
	}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Integer.lowestOneBit(i)   Equals k where k is the position of the first one in the binary
//Integer.highestOneBit(i)  Equals k where k is the position of the last one in the binary
//Integer.bitCount(i)       returns the number of one-bits
//Collections.sort(A,(p1,p2)->(int)(p2.x-p1.x)) To sort ArrayList in descending order wrt values of x.
//            Arrays.parallelSort(a,new Comparator<TPair>() {
//      		public int compare(TPair a,TPair b) {
//        			if(a.y==b.y) return a.x-b.x;
//        			return b.y-a.y;
//        		}
//        	});
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//PrimeFactors
    public static ArrayList<Long> primeFactors(long n) {
        ArrayList<Long> arr = new ArrayList<>();
        if (n % 2 == 0)
            arr.add((long) 2);
        while (n % 2 == 0)
            n /= 2;
        for (long i = 3; i <= Math.sqrt(n); i += 2) {
            int flag = 0;
            while (n % i == 0) {
                n /= i;
                flag = 1;
            }
            if (flag == 1)
                arr.add(i);
        }
        if (n > 2)
            arr.add(n);
        return arr;
    }
//Pair Class
	static class Pair implements Comparable<Pair>{
		int x;
		int y;
		public Pair(int x, int y) {
			this.x = x;
			this.y = y;
		}
		@Override
		public int compareTo(Pair o) {
			if(this.x==o.x){
			    return (this.y-o.y);
			}
			return (this.x-o.x);
		}
	}
	static class TPair{
		int min;
		int max;
		int c;
		public TPair(int min, int max, int c) {
			this.min = min;
			this.max = max;
			this.c = c;
		}
	}
//nCr
	static long ncr(long n, long k) {
        long ret = 1;
        for (long x = n; x > n - k; x--) {
            ret *= x;
            ret /= (n - x + 1);
        }

        return ret;
    }
	static long finextDoubleMMI_fermat(long n,int M)
    {
        return fastExpo(n,M-2);
    }

    static long nCrModPFermat(int n, int r, int p)
    {
        if (r == 0)
            return 1;
        long[] fac = new long[n+1];
        fac[0] = 1;
        for (int i = 1 ;i <= n; i++)
            fac[i] = fac[i-1] * i % p;
        return (fac[n]* finextDoubleMMI_fermat(fac[r], p)% p * finextDoubleMMI_fermat(fac[n-r], p) % p) % p;
    }
//Merge Sort
	static void merge(long arr[], int l, int m, int r)
    {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;

        /* Create temp arrays */
        long L[] = new long [n1];
        long R[] = new long [n2];

        /*Copy data to temp arrays*/
        for (int i=0; i<n1; ++i)
            L[i] = arr[l + i];
        for (int j=0; j<n2; ++j)
            R[j] = arr[m + 1+ j];

        /* Merge the temp arrays */

        // Initial indexes of first and second subarrays
        int i = 0, j = 0;

        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        /* Copy remaining elements of L[] if any */
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }

        /* Copy remaining elements of R[] if any */
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    // Main function that sorts arr[l..r] using
    // merge()
    static void sort(long arr[], int l, int r)
    {
        if (l < r)
        {
            // Find the middle point
            int m = (l+r)/2;

            // Sort first and second halves
            sort(arr, l, m);
            sort(arr , m+1, r);

            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }
//Brian Kernighan’s Algorithm
    static long countSetBits(long n){
        if(n==0) return 0;
        return 1+countSetBits(n&(n-1));
    }
//Factorial
    static long factorial(long n){
        if(n==1) return 1;
        if(n==2) return 2;
        if(n==3) return 6;
        return n*factorial(n-1);
    }
//Euclidean Algorithm
    static long gcd(long A,long B){
        if(B==0) return A;
        return gcd(B,A%B);
    }
//Modular Exponentiation
    static long fastExpo(long x,long n){
        if(n==0) return 1;
        if((n&1)==0) return fastExpo((x*x)%MOD,n/2)%MOD;
        return ((x%MOD)*fastExpo((x*x)%MOD,(n-1)/2))%MOD;
    }
//AKS Algorithm
    static boolean isPrime(long n){
        if(n<=1) return false;
        if(n<=3) return true;
        if(n%2==0 || n%3==0) return false;
        for(int i=5;i<=Math.sqrt(n);i+=6)
            if(n%i==0 || n%(i+2)==0) return false;
        return true;
    }
//Reverse an array
    static <T> void reverse(T arr[],int l,int r){
    	Collections.reverse(Arrays.asList(arr).subList(l, r));
    }
//Sieve of eratosthenes
    static int[] findPrimes(int n){
        boolean isPrime[]=new boolean[n+1];
        ArrayList<Integer> a=new ArrayList<>();
        int result[];
        Arrays.fill(isPrime,true);
        isPrime[0]=false;
        isPrime[1]=false;
        for(int i=2;i*i<=n;++i){
            if(isPrime[i]==true){
                for(int j=i*i;j<=n;j+=i) isPrime[j]=false;
            }
        }
        for(int i=0;i<=n;i++) if(isPrime[i]==true) a.add(i);
        result=new int[a.size()];
        for(int i=0;i<a.size();i++) result[i]=a.get(i);
        return result;

    }
//Indivisual factors of all nos till n
    static ArrayList<Integer>[] indiFactors(int n){
    	ArrayList<Integer>[] A = new ArrayList[n+1];
    	for(int i = 0; i <= n; i++) {
    		A[i] = new ArrayList<>();
    	}
    	int[] sieve = new int[n+1];
    	for(int i=2;i<=n;i++) {
       		if(sieve[i]==0) {
       			for(int j=i;j<=n;j+=i) if(sieve[j]==0) {
       				//sieve[j]=i;
       				A[i].add(j);
       			}
       		}
       	}
    	return A;
    }
//Segmented Sieve
    static boolean[] segmentedSieve(long l, long r){
    	boolean[] segSieve = new boolean[(int)(r-l+1)];
    	Arrays.fill(segSieve, true);
    	int[] prePrimes = findPrimes((int)Math.sqrt(r));
    	for(int p:prePrimes) {
    		long low = (l/p)*p;
    		if(low < l) {
    			low += p;
    		}
    		if(low == p) {
    			low += p;
    		}
    		for(long j = low; j<= r; j += p) {
    			segSieve[(int) (j-l)] = false;
    		}
    	}
    	if(l==1) {
    		segSieve[0] = false;
    	}
    	return segSieve;
    }
//Euler Totent function
    static long countCoprimes(long n){
        ArrayList<Long> prime_factors=new ArrayList<>();
        long x=n,flag=0;
        while(x%2==0){
            if(flag==0) prime_factors.add(2L);
            flag=1;
            x/=2;
        }
        for(long i=3;i*i<=x;i+=2){
            flag=0;
            while(x%i==0){
                if(flag==0) prime_factors.add(i);
                flag=1;
                x/=i;
            }
        }
        if(x>2) prime_factors.add(x);
        double ans=(double)n;
        for(Long p:prime_factors){
            ans*=(1.0-(Double)1.0/p);
        }
        return (long)ans;
    }
	static long modulo = (long)1e9+7;
	public static long modinv(long x){
	    return modpow(x, modulo-2);
	}
	public static long modpow(long a, long b){
	    if(b==0){
	        return 1;
	    }
	    long x = modpow(a, b/2);
	    x = (x*x)%modulo;
	    if(b%2==1){
	        return (x*a)%modulo;
	    }
	    return x;
	}
	public static class FastReader {
		BufferedReader br;
		StringTokenizer st;
		//it reads the data about the specified point and divide the data about it ,it is quite fast
		//than using direct

		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (Exception r) {
					r.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());//converts string to integer
		}

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

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

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (Exception r) {
				r.printStackTrace();
			}
			return str;
		}
	}
}


import java.util.*;
import java.lang.*;
import java.math.*;
import java.awt.Checkbox;
import java.awt.image.ConvolveOp;
import java.io.*;
import java.text.DecimalFormat;
import java.lang.reflect.Array;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.util.*;
public class Codeforces{
	public static PrintWriter out = new PrintWriter (new BufferedOutputStream(System.out));
	static long MOD = (long)(1e9+7);
	//static long MOD = 998244353;
	static FastReader sc = new FastReader();
	static int pInf = Integer.MAX_VALUE;
	static int nInf = Integer.MIN_VALUE;
	public static void main(String[] args){
		int test = 1;
		//test = sc.nextInt();
		while(test-->0){
			int n = sc.nextInt();
			int m = sc.nextInt();
			int x = sc.nextInt();
			int y = sc.nextInt();
			for(int i = y; i >= 1; i--) {
				out.println(x+" "+i);
			}
			for(int i = y+1; i <= m; i++) {
				out.println(x+" "+i);
			}
			int c = 0;
			for(int i = x+1; i <= n; i++) {
				if(c==0) {
					c=1;
					for(int j = m; j >= 1; j--) {
						out.println(i+" "+j);
					}
				}
				else {
					c=0;
					for(int j = 1; j <= m; j++) {
						out.println(i+" "+j);
					}
				}
			}
			for(int i = x-1; i >= 1; i--) {
				if(c==0) {
					c=1;
					for(int j = m; j >= 1; j--) {
						out.println(i+" "+j);
					}
				}
				else {
					c=0;
					for(int j = 1; j <= m; j++) {
						out.println(i+" "+j);
					}
				}
			}
  		}
		out.close();
	}
	public static long mul(long a, long b){
	    return ((a%MOD)*(b%MOD))%MOD;
	}
	public static long add(long a, long b){
	    return ((a%MOD)+(b%MOD))%MOD;
	}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Integer.lowestOneBit(i)   Equals k where k is the position of the first one in the binary
//Integer.highestOneBit(i)  Equals k where k is the position of the last one in the binary
//Integer.bitCount(i)       returns the number of one-bits
//Collections.sort(A,(p1,p2)->(int)(p2.x-p1.x)) To sort ArrayList in descending order wrt values of x.
//            Arrays.parallelSort(a,new Comparator<TPair>() {
//      		public int compare(TPair a,TPair b) {
//        			if(a.y==b.y) return a.x-b.x;
//        			return b.y-a.y;
//        		}
//        	});
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//PrimeFactors
    public static ArrayList<Long> primeFactors(long n) {
        ArrayList<Long> arr = new ArrayList<>();
        if (n % 2 == 0)
            arr.add((long) 2);
        while (n % 2 == 0)
            n /= 2;
        for (long i = 3; i <= Math.sqrt(n); i += 2) {
            int flag = 0;
            while (n % i == 0) {
                n /= i;
                flag = 1;
            }
            if (flag == 1)
                arr.add(i);
        }
        if (n > 2)
            arr.add(n);
        return arr;
    }
//Pair Class
	static class Pair implements Comparable<Pair>{
		int x;
		int y;
		public Pair(int x, int y) {
			this.x = x;
			this.y = y;
		}
		@Override
		public int compareTo(Pair o) {
			if(this.x==o.x){
			    return (this.y-o.y);
			}
			return (this.x-o.x);
		}
	}
	static class TPair{
		int min;
		int max;
		int c;
		public TPair(int min, int max, int c) {
			this.min = min;
			this.max = max;
			this.c = c;
		}
	}
//nCr
	static long ncr(long n, long k) {
        long ret = 1;
        for (long x = n; x > n - k; x--) {
            ret *= x;
            ret /= (n - x + 1);
        }

        return ret;
    }
	static long finextDoubleMMI_fermat(long n,int M)
    {
        return fastExpo(n,M-2);
    }

    static long nCrModPFermat(int n, int r, int p)
    {
        if (r == 0)
            return 1;
        long[] fac = new long[n+1];
        fac[0] = 1;
        for (int i = 1 ;i <= n; i++)
            fac[i] = fac[i-1] * i % p;
        return (fac[n]* finextDoubleMMI_fermat(fac[r], p)% p * finextDoubleMMI_fermat(fac[n-r], p) % p) % p;
    }
//Merge Sort
	static void merge(long arr[], int l, int m, int r)
    {
        // Find sizes of two subarrays to be merged
        int n1 = m - l + 1;
        int n2 = r - m;

        /* Create temp arrays */
        long L[] = new long [n1];
        long R[] = new long [n2];

        /*Copy data to temp arrays*/
        for (int i=0; i<n1; ++i)
            L[i] = arr[l + i];
        for (int j=0; j<n2; ++j)
            R[j] = arr[m + 1+ j];

        /* Merge the temp arrays */

        // Initial indexes of first and second subarrays
        int i = 0, j = 0;

        // Initial index of merged subarry array
        int k = l;
        while (i < n1 && j < n2)
        {
            if (L[i] <= R[j])
            {
                arr[k] = L[i];
                i++;
            }
            else
            {
                arr[k] = R[j];
                j++;
            }
            k++;
        }

        /* Copy remaining elements of L[] if any */
        while (i < n1)
        {
            arr[k] = L[i];
            i++;
            k++;
        }

        /* Copy remaining elements of R[] if any */
        while (j < n2)
        {
            arr[k] = R[j];
            j++;
            k++;
        }
    }

    // Main function that sorts arr[l..r] using
    // merge()
    static void sort(long arr[], int l, int r)
    {
        if (l < r)
        {
            // Find the middle point
            int m = (l+r)/2;

            // Sort first and second halves
            sort(arr, l, m);
            sort(arr , m+1, r);

            // Merge the sorted halves
            merge(arr, l, m, r);
        }
    }
//Brian Kernighan’s Algorithm
    static long countSetBits(long n){
        if(n==0) return 0;
        return 1+countSetBits(n&(n-1));
    }
//Factorial
    static long factorial(long n){
        if(n==1) return 1;
        if(n==2) return 2;
        if(n==3) return 6;
        return n*factorial(n-1);
    }
//Euclidean Algorithm
    static long gcd(long A,long B){
        if(B==0) return A;
        return gcd(B,A%B);
    }
//Modular Exponentiation
    static long fastExpo(long x,long n){
        if(n==0) return 1;
        if((n&1)==0) return fastExpo((x*x)%MOD,n/2)%MOD;
        return ((x%MOD)*fastExpo((x*x)%MOD,(n-1)/2))%MOD;
    }
//AKS Algorithm
    static boolean isPrime(long n){
        if(n<=1) return false;
        if(n<=3) return true;
        if(n%2==0 || n%3==0) return false;
        for(int i=5;i<=Math.sqrt(n);i+=6)
            if(n%i==0 || n%(i+2)==0) return false;
        return true;
    }
//Reverse an array
    static <T> void reverse(T arr[],int l,int r){
    	Collections.reverse(Arrays.asList(arr).subList(l, r));
    }
//Sieve of eratosthenes
    static int[] findPrimes(int n){
        boolean isPrime[]=new boolean[n+1];
        ArrayList<Integer> a=new ArrayList<>();
        int result[];
        Arrays.fill(isPrime,true);
        isPrime[0]=false;
        isPrime[1]=false;
        for(int i=2;i*i<=n;++i){
            if(isPrime[i]==true){
                for(int j=i*i;j<=n;j+=i) isPrime[j]=false;
            }
        }
        for(int i=0;i<=n;i++) if(isPrime[i]==true) a.add(i);
        result=new int[a.size()];
        for(int i=0;i<a.size();i++) result[i]=a.get(i);
        return result;

    }
//Indivisual factors of all nos till n
    static ArrayList<Integer>[] indiFactors(int n){
    	ArrayList<Integer>[] A = new ArrayList[n+1];
    	for(int i = 0; i <= n; i++) {
    		A[i] = new ArrayList<>();
    	}
    	int[] sieve = new int[n+1];
    	for(int i=2;i<=n;i++) {
       		if(sieve[i]==0) {
       			for(int j=i;j<=n;j+=i) if(sieve[j]==0) {
       				//sieve[j]=i;
       				A[i].add(j);
       			}
       		}
       	}
    	return A;
    }
//Segmented Sieve
    static boolean[] segmentedSieve(long l, long r){
    	boolean[] segSieve = new boolean[(int)(r-l+1)];
    	Arrays.fill(segSieve, true);
    	int[] prePrimes = findPrimes((int)Math.sqrt(r));
    	for(int p:prePrimes) {
    		long low = (l/p)*p;
    		if(low < l) {
    			low += p;
    		}
    		if(low == p) {
    			low += p;
    		}
    		for(long j = low; j<= r; j += p) {
    			segSieve[(int) (j-l)] = false;
    		}
    	}
    	if(l==1) {
    		segSieve[0] = false;
    	}
    	return segSieve;
    }
//Euler Totent function
    static long countCoprimes(long n){
        ArrayList<Long> prime_factors=new ArrayList<>();
        long x=n,flag=0;
        while(x%2==0){
            if(flag==0) prime_factors.add(2L);
            flag=1;
            x/=2;
        }
        for(long i=3;i*i<=x;i+=2){
            flag=0;
            while(x%i==0){
                if(flag==0) prime_factors.add(i);
                flag=1;
                x/=i;
            }
        }
        if(x>2) prime_factors.add(x);
        double ans=(double)n;
        for(Long p:prime_factors){
            ans*=(1.0-(Double)1.0/p);
        }
        return (long)ans;
    }
	static long modulo = (long)1e9+7;
	public static long modinv(long x){
	    return modpow(x, modulo-2);
	}
	public static long modpow(long a, long b){
	    if(b==0){
	        return 1;
	    }
	    long x = modpow(a, b/2);
	    x = (x*x)%modulo;
	    if(b%2==1){
	        return (x*a)%modulo;
	    }
	    return x;
	}
	public static class FastReader {
		BufferedReader br;
		StringTokenizer st;
		//it reads the data about the specified point and divide the data about it ,it is quite fast
		//than using direct

		public FastReader() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (Exception r) {
					r.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());//converts string to integer
		}

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

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

		String nextLine() {
			String str = "";
			try {
				str = br.readLine();
			} catch (Exception r) {
				r.printStackTrace();
			}
			return str;
		}
	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String s[] = br.readLine().trim().split("\\s+");
		int rl = Integer.parseInt(s[0]);
		int cl = Integer.parseInt(s[1]);
		int r = Integer.parseInt(s[2]);
		int c = Integer.parseInt(s[3]);
		row(new boolean[rl], r, c, cl);
	}

	private static void row(boolean[] row, int r, int c, int cl) {
		System.out.println(r + " " + c);
		boolean[] col = new boolean[cl];
		col[c - 1] = true;
		for (int i = 0; i < cl; i++) {
			if (!col[i]) {
				System.out.println(r + " " + (i + 1));
				c = i + 1;
			}
		}
		row[r-1] = true;
		for (int i = 0; i < row.length; i++) {
			if (!row[i]) {
				row(row, i+1, c, cl);
			}
		}
	}
}


public class Main {
	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String s[] = br.readLine().trim().split("\\s+");
		int rl = Integer.parseInt(s[0]);
		int cl = Integer.parseInt(s[1]);
		int r = Integer.parseInt(s[2]);
		int c = Integer.parseInt(s[3]);
		row(new boolean[rl], r, c, cl);
	}

	private static void row(boolean[] row, int r, int c, int cl) {
		System.out.println(r + " " + c);
		boolean[] col = new boolean[cl];
		col[c - 1] = true;
		for (int i = 0; i < cl; i++) {
			if (!col[i]) {
				System.out.println(r + " " + (i + 1));
				c = i + 1;
			}
		}
		row[r-1] = true;
		for (int i = 0; i < row.length; i++) {
			if (!row[i]) {
				row(row, i+1, c, cl);
			}
		}
	}
}


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

public class B{

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

		FastScanner sc=new FastScanner();
		int t = 1;
		first : while(t-- != 0) {
			int n =sc.nextInt();
			int m = sc.nextInt();
			int x = sc.nextInt();
			int y = sc.nextInt();
			System.out.println(x+" "+y);
			boolean flag = true;
			for(int i = x; i>=1; i--) {
				if(!flag) {
					for(int j=1; j<=m; j++) {
						if(i == x && j == y)
							continue;
						System.out.println(i+" "+j);
					}
					flag = !flag;
				}
				else {
					for(int j=m; j>=1; j--) {
						if(i == x && j == y)
							continue;
						System.out.println(i+" "+j);
					}
				}
				flag = !flag;
			}

			for(int i = x+1; i<=n; i++) {
				if(!flag) {
					for(int j=m; j>=1; j--) {
						if(i == x && j == y)
							continue;
						System.out.println(i+" "+j);
					}
					flag = !flag;
				}
				else {
					for(int j=1; j<=m; j++) {
						if(i == x && j == y)
							continue;
						System.out.println(i+" "+j);
					}
					flag = !flag;
				}
			}

        }

	}

	static void sort(int[] a) {
		ArrayList<Integer> l=new ArrayList<>();
		for (int i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}

	static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens())
				try {
					st=new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}
		int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++) a[i]=nextInt();
			return a;
		}
		long nextLong() {
			return Long.parseLong(next());
		}
	}
}


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

public class B{

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

		FastScanner sc=new FastScanner();
		int t = 1;
		first : while(t-- != 0) {
			int n =sc.nextInt();
			int m = sc.nextInt();
			int x = sc.nextInt();
			int y = sc.nextInt();
			System.out.println(x+" "+y);
			boolean flag = true;
			for(int i = x; i>=1; i--) {
				if(!flag) {
					for(int j=1; j<=m; j++) {
						if(i == x && j == y)
							continue;
						System.out.println(i+" "+j);
					}
					flag = !flag;
				}
				else {
					for(int j=m; j>=1; j--) {
						if(i == x && j == y)
							continue;
						System.out.println(i+" "+j);
					}
				}
				flag = !flag;
			}

			for(int i = x+1; i<=n; i++) {
				if(!flag) {
					for(int j=m; j>=1; j--) {
						if(i == x && j == y)
							continue;
						System.out.println(i+" "+j);
					}
				}
				else {
					for(int j=1; j<=m; j++) {
						if(i == x && j == y)
							continue;
						System.out.println(i+" "+j);
					}
					flag = !flag;
				}
			}

        }

	}

	static void sort(int[] a) {
		ArrayList<Integer> l=new ArrayList<>();
		for (int i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}

	static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens())
				try {
					st=new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}
		int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++) a[i]=nextInt();
			return a;
		}
		long nextLong() {
			return Long.parseLong(next());
		}
	}
}


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

public class B{

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

		FastScanner sc=new FastScanner();
		int t = 1;
		first : while(t-- != 0) {
			int n =sc.nextInt();
			int m = sc.nextInt();
			int x = sc.nextInt();
			int y = sc.nextInt();
			System.out.println(x+" "+y);
			for(int i = x; i>=1; i--) {
				for(int j = m; j>=1; j--) {
					if(i == x && j == y) {
						continue;
					}
					System.out.println(i+" "+j);
				}
			}

			for(int i = x+1; i<=n; i++) {
				for(int j = 1; j<=m; j++) {
					System.out.println(i+" "+j);
				}
			}

        }

	}

	static void sort(int[] a) {
		ArrayList<Integer> l=new ArrayList<>();
		for (int i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}

	static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens())
				try {
					st=new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}
		int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++) a[i]=nextInt();
			return a;
		}
		long nextLong() {
			return Long.parseLong(next());
		}
	}
}


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

public class B{

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

		FastScanner sc=new FastScanner();
		int t = 1;
		first : while(t-- != 0) {
			int n =sc.nextInt();
			int m = sc.nextInt();
			int x = sc.nextInt();
			int y = sc.nextInt();
			System.out.println(x+" "+y);
			boolean flag = true;
			for(int i = x; i>=1; i--) {
				if(flag) {
					for(int j=1; j<=m; j++) {
						if(i == x && j == y)
							continue;
						System.out.println(i+" "+j);
					}
					flag = !flag;
				}
				else {
					for(int j=m; j>=1; j--) {
						if(i == x && j == y)
							continue;
						System.out.println(i+" "+j);
					}
					flag = !flag;
				}

			}

			for(int i = x+1; i<=n; i++) {
				if(!flag) {
					for(int j=m; j>=1; j--) {
						if(i == x && j == y)
							continue;
						System.out.println(i+" "+j);
					}
					flag = !flag;
				}
				else {
					for(int j=1; j<=m; j++) {
						if(i == x && j == y)
							continue;
						System.out.println(i+" "+j);
					}
					flag = !flag;
				}
			}

        }

	}

	static void sort(int[] a) {
		ArrayList<Integer> l=new ArrayList<>();
		for (int i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}

	static class FastScanner {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st=new StringTokenizer("");
		String next() {
			while (!st.hasMoreTokens())
				try {
					st=new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}
		int[] readArray(int n) {
			int[] a=new int[n];
			for (int i=0; i<n; i++) a[i]=nextInt();
			return a;
		}
		long nextLong() {
			return Long.parseLong(next());
		}
	}
}


import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class b {
	static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;
public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }
public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');
if (neg)
                return -ret;
            return ret;
        }
public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }
public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }
if (neg)
                return -ret;
            return ret;
        }
private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }
private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }
public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }

	//User Defined Method start
	public static int inputInt()throws IOException
    {
        return sc.nextInt();
    }
    public static long inputLong()throws IOException
    {
        return sc.nextLong();
    }
    public static double inputDouble()throws IOException
    {
        return sc.nextDouble();
    }
    public static String inputString()throws IOException
    {
        return sc.readLine();
    }
    public static void print(String a)throws IOException
    {
        bw.write(a);
    }
    public static void printSp(String a)throws IOException
    {
        bw.write(a+" ");
    }
    public static void println(String a)throws IOException
    {
        bw.write(a+"\n");
    }
	//User Defined Method End

  //Helper Function - start
    private static void printArray(int arr[])
    {
    	for(int i:arr)
    		System.out.print(i+" ");
    	System.out.println();
    }

    private static void inputArray(int arr[]) throws IOException
    {
    	for(int i=0;i<arr.length;i++)
    	{
    		arr[i] = inputInt();
    	}
    }

    //helper Function - End

	//Defining input and output stream obj - Start
    static Reader sc=new Reader();
    static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    static StringBuilder s = new StringBuilder("");
    //Defining input and output stream obj - End

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

			int n = inputInt();
			int m = inputInt();
			int x = inputInt();
			int y = inputInt();

			boolean [][]arr = new boolean[n][m];
			giveAns(arr,x,y,n,m);

		System.out.println(s);
	}

	private static void giveAns(boolean [][]arr,int x,int y,int n,int m)
	{

			while(x>0)
			{
				s.append(x + " " + y + "\n");
				arr[x-1][y-1] = true;
				x--;
			}

		while(y>0)
		{
				if(arr[0][y-1] != true){
					s.append(1 + " " + y + "\n");
					arr[0][y-1] = true;
				}
			y--;
		}

		int row = 0;
		boolean forward = true;
		while(row < n)
		{
			if(forward){
				int j=0;
				while(j<m)
				{
					if(arr[row][j] != true){
						s.append((row+1) + " " + (j+1) + "\n");
						arr[row][j] = true;
					}
					j++;
				}
				forward = false;
			}
			else{
				int j=m-1;
				while(j>=0)
				{
					if(arr[row][j] != true){
						s.append((row+1) + " " + (j+1) + "\n");
						arr[row][j] = true;
					}
					j--;
				}
				forward = true;
			}
			row++;
		}
	}

}


import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;

public class b {
	static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;
public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }
public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }
public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');
if (neg)
                return -ret;
            return ret;
        }
public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }
public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }
if (neg)
                return -ret;
            return ret;
        }
private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }
private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }
public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }

	//User Defined Method start
	public static int inputInt()throws IOException
    {
        return sc.nextInt();
    }
    public static long inputLong()throws IOException
    {
        return sc.nextLong();
    }
    public static double inputDouble()throws IOException
    {
        return sc.nextDouble();
    }
    public static String inputString()throws IOException
    {
        return sc.readLine();
    }
    public static void print(String a)throws IOException
    {
        bw.write(a);
    }
    public static void printSp(String a)throws IOException
    {
        bw.write(a+" ");
    }
    public static void println(String a)throws IOException
    {
        bw.write(a+"\n");
    }
	//User Defined Method End

  //Helper Function - start
    private static void printArray(int arr[])
    {
    	for(int i:arr)
    		System.out.print(i+" ");
    	System.out.println();
    }

    private static void inputArray(int arr[]) throws IOException
    {
    	for(int i=0;i<arr.length;i++)
    	{
    		arr[i] = inputInt();
    	}
    }

    //helper Function - End

	//Defining input and output stream obj - Start
    static Reader sc=new Reader();
    static BufferedWriter bw=new BufferedWriter(new OutputStreamWriter(System.out));
    static StringBuilder s = new StringBuilder("");
    //Defining input and output stream obj - End

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

			int n = inputInt();
			int m = inputInt();
			int x = inputInt();
			int y = inputInt();

			boolean [][]arr = new boolean[n][m];
			giveAns(arr,x,y,n,m);

		System.out.println(s);
	}

	private static void giveAns(boolean [][]arr,int x,int y,int n,int m)
	{
		boolean isUp = false;
		if(x <= n/2)
		{
			while(x>0)
			{
				s.append(x + " " + y + "\n");
				arr[x-1][y-1] = true;
				x--;
			}
			isUp = true;
		}
		else
		{
			while(x<n)
			{
				s.append(x + " " + y + "\n");
				arr[x-1][y-1] = true;
				x++;
			}
		}

		while(y>0)
		{
			if(isUp == true ){
				if(arr[0][y-1] != true){
					s.append(1 + " " + y + "\n");
					arr[0][y-1] = true;
				}
			}
			else
			{
				 if(arr[n-1][y-1] != true){
					s.append(n + " " + y + "\n");
					arr[n-1][y-1] = true;
				 }
			}
			y--;
		}

		int row = 0;
		boolean forward = true;
		while(row < n)
		{
			if(forward){
				int j=0;
				while(j<m)
				{
					if(arr[row][j] != true){
						s.append((row+1) + " " + (j+1) + "\n");
						arr[row][j] = true;
					}
					j++;
				}
				forward = false;
			}
			else{
				int j=m-1;
				while(j>=0)
				{
					if(arr[row][j] != true){
						s.append((row+1) + " " + (j+1) + "\n");
						arr[row][j] = true;
					}
					j--;
				}
				forward = true;
			}
			row++;
		}
	}

}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class B {
	static int totalVisited = 1;

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

		String[] inp = br.readLine().split(" ");

		int noRows = Integer.parseInt(inp[0]);
		int noCol = Integer.parseInt(inp[1]);
		int initialX = Integer.parseInt(inp[2]) - 1;
		int intialY = Integer.parseInt(inp[3]) - 1;

		int m[][] = new int[noRows][noCol];

		m[initialX][intialY] = 1;
		System.out.println((initialX + 1) + " " + (intialY + 1));
		if (!(initialX == 1 && intialY == 1)) {
			int y = visitCurrentRow(m, initialX, intialY, noRows, noCol);
			visitNextRow(m, initialX, y, noRows, noCol);
		}
	}

	public static void visitNextRow(int[][] matrix, int currentX, int currentY, int noRows, int noCol) {
		int y = 0;
		int x = 0;
		if (currentX + 1 == noRows) {
			System.out.println(1 + " " + (currentY + 1));
			matrix[0][currentY] = 1;
			totalVisited++;
			x = 0;
			y = visitCurrentRow(matrix, 0, currentY, noRows, noCol);
		} else {
			System.out.println((currentX + 2) + " " + (currentY + 1));
			matrix[currentX + 1][currentY] = 1;
			x = currentX + 1;
			totalVisited++;
			y = visitCurrentRow(matrix, currentX + 1, currentY, noRows, noCol);
		}
		if (totalVisited == (noRows * noCol))
			return;
		else
			visitNextRow(matrix, x, y, noRows, noCol);

	}

	public static int visitCurrentRow(int[][] matrix, int currentX, int currentY, int noRows, int noCol) {

		int lastY = currentY;
		int cellsVisited = 0;
		if (currentY != 0) {
			for (int j = currentY - 1; j >= 0; j--) {
				cellsVisited++;
				matrix[currentX][j] = 1;
				System.out.println((currentX + 1) + " " + (j + 1));
				lastY = j;
			}
		}
		if (cellsVisited != noCol - 1) {
			for (int j = currentY + 1; j < noCol; j++) {
				cellsVisited++;
				matrix[currentX][j] = 1;
				System.out.println((currentX + 1) + " " + (j + 1));
				lastY = j;
			}

		}
		totalVisited += cellsVisited;
		return lastY;

	}

	public static void visitNextCell(int[][] matrix, int cellToVisitX, int cellToVisitY, int noRows, int noCol) {

	}
}


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class B {
	static int totalVisited = 1;

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

		String[] inp = br.readLine().split(" ");

		int noRows = Integer.parseInt(inp[0]);
		int noCol = Integer.parseInt(inp[1]);
		int initialX = Integer.parseInt(inp[2]) - 1;
		int intialY = Integer.parseInt(inp[3]) - 1;

		int m[][] = new int[noRows][noCol];

		m[initialX][intialY] = 1;
		System.out.println((initialX + 1) + " " + (intialY + 1));
		if (!(noRows == 1 && noCol == 1)) {
			int y = visitCurrentRow(m, initialX, intialY, noRows, noCol);
			visitNextRow(m, initialX, y, noRows, noCol);
		}
	}

	public static void visitNextRow(int[][] matrix, int currentX, int currentY, int noRows, int noCol) {
		int y = 0;
		int x = 0;
		if (currentX + 1 == noRows) {
			System.out.println(1 + " " + (currentY + 1));
			matrix[0][currentY] = 1;
			totalVisited++;
			x = 0;
			y = visitCurrentRow(matrix, 0, currentY, noRows, noCol);
		} else {
			System.out.println((currentX + 2) + " " + (currentY + 1));
			matrix[currentX + 1][currentY] = 1;
			x = currentX + 1;
			totalVisited++;
			y = visitCurrentRow(matrix, currentX + 1, currentY, noRows, noCol);
		}
		if (totalVisited == (noRows * noCol))
			return;
		else
			visitNextRow(matrix, x, y, noRows, noCol);

	}

	public static int visitCurrentRow(int[][] matrix, int currentX, int currentY, int noRows, int noCol) {

		int lastY = currentY;
		int cellsVisited = 0;
		if (currentY != 0) {
			for (int j = currentY - 1; j >= 0; j--) {
				cellsVisited++;
				matrix[currentX][j] = 1;
				System.out.println((currentX + 1) + " " + (j + 1));
				lastY = j;
			}
		}
		if (cellsVisited != noCol - 1) {
			for (int j = currentY + 1; j < noCol; j++) {
				cellsVisited++;
				matrix[currentX][j] = 1;
				System.out.println((currentX + 1) + " " + (j + 1));
				lastY = j;
			}

		}
		totalVisited += cellsVisited;
		return lastY;

	}

	public static void visitNextCell(int[][] matrix, int cellToVisitX, int cellToVisitY, int noRows, int noCol) {

	}
}


//import for Scanner and other utility classes
import java.util.*;

public class graph2 {

	    public static int fun(int n,int m, int x, int y){

	    	System.out.println(x+" "+y);
	    	for(int i=1;i<=m;i++)
	    		if(i!=y)
	    			System.out.println(x+" "+i);

	    	boolean fl=false;
	    	for(int i=x-1;i>=1;i--) {
	    		if(!fl) {
	    			for(int j=m;j>=1;j--) {
	    				System.out.println(i+" "+j);
	    			}
	    			fl=!fl;
	    		}
	    		else {
	    			if(!fl) {
		    			for(int j=1;j<=m;j++) {
		    				System.out.println(i+" "+j);
		    			}
		    			fl=!fl;
		    		}

	    		}

	    	}

	    	for(int i=x+1;i<=n;i++) {
	    		if(fl) {
	    			for(int j=1;j<=m;j++) {
	    				System.out.println(i+" "+j);
	    			}
	    			fl=!fl;
	    		}

	    		else {

	    			for(int j=m;j>=1;j--) {
	    				System.out.println(i+" "+j);
	    			}
	    			fl=!fl;

	    		}

	    	}

	    	return 0;
	    }

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

		Scanner s = new Scanner(System.in);
		//int t=s.nextInt();
		int t=1;

		while(t>0) {
			t--;
			int n=s.nextInt();
			int m=s.nextInt();
			int x=s.nextInt();
			int y=s.nextInt();
			fun(n,m,x,y);

			}

		}

	}


import java.util.*;

public class graph2 {

	    public static int fun(int n,int m, int x, int y){

	    	for(int i=1;i<=m;i++)
	    		System.out.println(x+" "+i);

	    	boolean fl=false;
	    	for(int i=x-1;i>=1;i--) {
	    		if(!fl) {
	    			for(int j=m;j>=1;j--) {
	    				System.out.println(i+" "+j);
	    			}
	    			fl=!fl;
	    		}
	    		else {
	    			if(!fl) {
		    			for(int j=1;j<=m;j++) {
		    				System.out.println(i+" "+j);
		    			}
		    			fl=!fl;
		    		}

	    		}

	    	}

	    	for(int i=x+1;i<=n;i++) {
	    		if(fl) {
	    			for(int j=1;j<=m;j++) {
	    				System.out.println(i+" "+j);
	    			}
	    			fl=!fl;
	    		}

	    		else {

	    			for(int j=m;j>=1;j--) {
	    				System.out.println(i+" "+j);
	    			}
	    			fl=!fl;

	    		}

	    	}

	    	return 0;
	    }

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

		Scanner s = new Scanner(System.in);
		//int t=s.nextInt();
		int t=1;

		while(t>0) {
			t--;
			int n=s.nextInt();
			int m=s.nextInt();
			int x=s.nextInt();
			int y=s.nextInt();
			fun(n,m,x,y);

			}

		}

	}


//import for Scanner and other utility classes
import java.util.*;

public class graph2 {

	    public static int fun(int n,int m, int x, int y){

	    	System.out.println(x+" "+y);
	    	for(int i=1;i<=m;i++)
	    		if(i!=y)
	    			System.out.println(x+" "+i);

	    	boolean fl=false;
	    	for(int i=x-1;i>=1;i--) {
	    		if(!fl) {
	    			for(int j=m;j>=1;j--) {
	    				System.out.println(i+" "+j);
	    			}
	    			fl=!fl;
	    		}
	    		else {

		    			for(int j=1;j<=m;j++) {
		    				System.out.println(i+" "+j);
		    			}
		    			fl=!fl;

	    		}

	    	}

	    	for(int i=x+1;i<=n;i++) {
	    		if(fl) {
	    			for(int j=1;j<=m;j++) {
	    				System.out.println(i+" "+j);
	    			}
	    			fl=!fl;
	    		}

	    		else {

	    			for(int j=m;j>=1;j--) {
	    				System.out.println(i+" "+j);
	    			}
	    			fl=!fl;

	    		}

	    	}

	    	return 0;
	    }

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

		Scanner s = new Scanner(System.in);
		//int t=s.nextInt();
		int t=1;

		while(t>0) {
			t--;
			int n=s.nextInt();
			int m=s.nextInt();
			int x=s.nextInt();
			int y=s.nextInt();
			fun(n,m,x,y);

			}

		}

	}


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

public class B664B{
	static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        private FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

	int[] nextIntArrayOne(int n) {
				int[] a = new int[n+1];
				for (int i = 1; i < n+1; i++)
					a[i] = nextInt();
				return a;
	}

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

	public static void main(String[] args) {
		FastReader s =new FastReader();

		StringBuilder str = new StringBuilder();

		int n = s.nextInt(), m  = s.nextInt();
		int x = s.nextInt(), y = s.nextInt();

		for(int i = y; i <= m ;i++) {
			str.append(x + " " + i +"\n");
		}

		for(int i = y - 1; i >= 1; i--) {
			str.append(x + " "+ i +"\n" );
		}

		boolean f = true;

		for(int i = x  - 1 ; i > 0; i-- ) {

			if(f) {
				for(int j = 1; j <= m ; j++) {
					str.append(i + " "+ j +"\n");
				}
				f = !f;
			}
			else {
				for(int k = m; k >= 1; k--) {
					str.append(i + " "+ k +"\n");
				}
				f= !f;
			}
		}

		int nx = x  + 1;
		int ny = x % 2 != 0 ? 1 : m;

		f = ny == 1 ? true : false;

		for(int i = nx; i <= n; i++) {
			if(f) {
				for(int j = 1; j <= m; j++) {
					str.append(i + " "+ j +"\n");
				}
				f =  !f;
			}else {
				for(int k = m; k >= 1; k--) {
					str.append(i + " "+ k +"\n");
				}
				f = !f;
			}

		}

		System.out.println(str);
	}

}


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

public class B664B{
	static class FastReader {

        BufferedReader br;
        StringTokenizer st;

        private FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

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

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

	int[] nextIntArrayOne(int n) {
				int[] a = new int[n+1];
				for (int i = 1; i < n+1; i++)
					a[i] = nextInt();
				return a;
	}

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

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

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

	public static void main(String[] args) {
		FastReader s =new FastReader();

		StringBuilder str = new StringBuilder();

		int n = s.nextInt(), m  = s.nextInt();
		int x = s.nextInt(), y = s.nextInt();

		for(int i = y; i <= m ;i++) {
			str.append(x + " " + i +"\n");
		}
		str.append(x + " "+ (y - 1) +"\n" );
		boolean f = true;

		for(int i = x  - 1 ; i > 0; i-- ) {

			if(f) {
				for(int j = 1; j <= m ; j++) {
					str.append(i + " "+ j +"\n");
				}
				f = !f;
			}
			else {
				for(int k = m; k >= 1; k--) {
					str.append(i + " "+ k +"\n");
				}
				f= !f;
			}
		}

		int nx = x  + 1;
		int ny = x % 2 != 0 ? 1 : m;

		f = ny == 1 ? true : false;

		for(int i = nx; i <= n; i++) {
			if(f) {
				for(int j = 1; j <= m; j++) {
					str.append(i + " "+ j +"\n");
				}
				f =  !f;
			}else {
				for(int k = m; k >= 1; k--) {
					str.append(i + " "+ k +"\n");
				}
				f = !f;
			}

		}

		System.out.println(str);
	}

}


import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;

import static java.lang.Math.*;

public class Cf182 implements Runnable
{
	static class InputReader
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;
		private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}

		public int read()
		{
			if (numChars==-1)
				throw new InputMismatchException();

			if (curChar >= numChars)
			{
				curChar = 0;
				try
				{
					numChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}

				if(numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine()
		{
			String str = "";
			try
			{
				str = br.readLine();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
			return str;
		}
		public int nextInt()
		{
			int c = read();

			while(isSpaceChar(c))
				c = read();

			int sgn = 1;

			if (c == '-')
			{
				sgn = -1;
				c = read();
			}

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

			return res * sgn;
		}

		public long nextLong()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			long res = 0;

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

		public double nextDouble()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.')
			{
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.')
			{
				c = read();
				double m = 1;
				while (!isSpaceChar(c))
				{
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public String readString()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do
			{
				res.appendCodePoint(c);
				c = read();
			}
			while (!isSpaceChar(c));

			return res.toString();
		}

		public boolean isSpaceChar(int c)
		{
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public String next()
		{
			return readString();
		}

		public interface SpaceCharFilter
		{
			public boolean isSpaceChar(int ch);
		}
	}
	public static void main(String args[]) throws Exception
	{
		new Thread(null, new Cf182(),"Main",1<<27).start();
	}

	public static long gcd(long a, long b)
	{
		if (a == 0)
			return b;
		return gcd(b % a, a);
	}
	//  array sorting by colm
public static void sortbyColumn(int arr[][], int col)
    {

        Arrays.sort(arr, new Comparator<int[]>() {

          @Override
          public int compare(final int[] entry1,
                             final int[] entry2) {

            if (entry1[col] > entry2[col])
                return 1;
            else
                return -1;
          }
        });
    }

	// gcd

	public static long findGCD(long arr[], int n)
	{
		long result = arr[0];
		for (int i = 1; i < n; i++)
			result = gcd(arr[i], result);
		return result;
	}
	// fibonaci
	static int fib(int n)
    {
        int a = 0, b = 1, c;
        if (n == 0)
            return a;
        for (int i = 2; i <= n; i++)
        {
            c = a + b;
            a = b;
            b = c;
        }
        return b;
    }

// sort a string
    public static String sortString(String inputString)
    {

        char tempArray[] = inputString.toCharArray();

        Arrays.sort(tempArray);

        return new String(tempArray);
    }
    // pair function

    // list.add(new Pair<>(sc.nextInt(), i + 1));
    //     Collections.sort(list, (a, b) -> Integer.compare(b.first, a.first));
    private static class Pair<F, S> {

        private F first;

        private S second;

        public Pair() {}

        public Pair(F first, S second) {
            this.first = first;
            this.second = second;
        }
    }

	// SortedArrayList<Integer> test = new SortedArrayList<Integer>();
    // test.insert(5);
            public static class SortedArrayList<T> extends ArrayList<T> {

            @SuppressWarnings("unchecked")
            public void insert(T value) {
                add(value);
                Comparable<T> cmp = (Comparable<T>) value;
                for (int i = size()-1; i > 0 && cmp.compareTo(get(i-1)) < 0; i--)
                    Collections.swap(this, i, i-1);
            }
        }

	public void run()
	{
		InputReader sc = new InputReader(System.in);
		PrintWriter w = new PrintWriter(System.out);
	    int n = sc.nextInt();
	    int m = sc.nextInt();
	    int x = sc.nextInt();
	    int y = sc.nextInt();

	    for(int i = x;i<=n;i++)
	        w.println(i+" "+y);

	    for(int i=1;i<x;i++)
	        w.println(i+" "+y);

	     int flag = 0;

	    for(int i=y+1;i<=m;i++)
	    {
	        if(flag == 0)
	        {
    	        for(int j = 1;j<=n;j++)
    	            w.println(j+" "+i);
    	       flag = 1;
	        }
	        else
	        {
	           for(int j = n;j>0;j--)
	                w.println(j+" "+i);
	           flag = 0;
	        }
	    }

	    for(int i=1;i<y;i++)
	    {
	        if(flag == 0)
	        {
    	        for(int j = 1;j<=n;j++)
    	            w.println(j+" "+i);
    	        flag = 1;
	        }
	        else
	        {
	           for(int j = n;j>0;j--)
	                w.println(j+" "+i);
	            flag = 0;
	        }
	    }

        w.flush();
	    w.close();
	}
}


import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;

import static java.lang.Math.*;

public class Cf182 implements Runnable
{
	static class InputReader
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;
		private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}

		public int read()
		{
			if (numChars==-1)
				throw new InputMismatchException();

			if (curChar >= numChars)
			{
				curChar = 0;
				try
				{
					numChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}

				if(numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine()
		{
			String str = "";
			try
			{
				str = br.readLine();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
			return str;
		}
		public int nextInt()
		{
			int c = read();

			while(isSpaceChar(c))
				c = read();

			int sgn = 1;

			if (c == '-')
			{
				sgn = -1;
				c = read();
			}

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

			return res * sgn;
		}

		public long nextLong()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			long res = 0;

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

		public double nextDouble()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.')
			{
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.')
			{
				c = read();
				double m = 1;
				while (!isSpaceChar(c))
				{
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public String readString()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do
			{
				res.appendCodePoint(c);
				c = read();
			}
			while (!isSpaceChar(c));

			return res.toString();
		}

		public boolean isSpaceChar(int c)
		{
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public String next()
		{
			return readString();
		}

		public interface SpaceCharFilter
		{
			public boolean isSpaceChar(int ch);
		}
	}
	public static void main(String args[]) throws Exception
	{
		new Thread(null, new Cf182(),"Main",1<<27).start();
	}

	public static long gcd(long a, long b)
	{
		if (a == 0)
			return b;
		return gcd(b % a, a);
	}
	//  array sorting by colm
public static void sortbyColumn(int arr[][], int col)
    {

        Arrays.sort(arr, new Comparator<int[]>() {

          @Override
          public int compare(final int[] entry1,
                             final int[] entry2) {

            if (entry1[col] > entry2[col])
                return 1;
            else
                return -1;
          }
        });
    }

	// gcd

	public static long findGCD(long arr[], int n)
	{
		long result = arr[0];
		for (int i = 1; i < n; i++)
			result = gcd(arr[i], result);
		return result;
	}
	// fibonaci
	static int fib(int n)
    {
        int a = 0, b = 1, c;
        if (n == 0)
            return a;
        for (int i = 2; i <= n; i++)
        {
            c = a + b;
            a = b;
            b = c;
        }
        return b;
    }

// sort a string
    public static String sortString(String inputString)
    {

        char tempArray[] = inputString.toCharArray();

        Arrays.sort(tempArray);

        return new String(tempArray);
    }
    // pair function

    // list.add(new Pair<>(sc.nextInt(), i + 1));
    //     Collections.sort(list, (a, b) -> Integer.compare(b.first, a.first));
    private static class Pair<F, S> {

        private F first;

        private S second;

        public Pair() {}

        public Pair(F first, S second) {
            this.first = first;
            this.second = second;
        }
    }

	// SortedArrayList<Integer> test = new SortedArrayList<Integer>();
    // test.insert(5);
            public static class SortedArrayList<T> extends ArrayList<T> {

            @SuppressWarnings("unchecked")
            public void insert(T value) {
                add(value);
                Comparable<T> cmp = (Comparable<T>) value;
                for (int i = size()-1; i > 0 && cmp.compareTo(get(i-1)) < 0; i--)
                    Collections.swap(this, i, i-1);
            }
        }

	public void run()
	{
		InputReader sc = new InputReader(System.in);
		PrintWriter w = new PrintWriter(System.out);
	    int n = sc.nextInt();
	    int m = sc.nextInt();
	    int x = sc.nextInt();
	    int y = sc.nextInt();

	    for(int i = x;i<=n;i++)
	        w.println(i+" "+y);

	    for(int i=x-1;i>=1;i--)
	        w.println(i+" "+y);

	     int flag = 0;

	    for(int i=y+1;i<=m;i++)
	    {
	        if(flag == 0)
	        {
    	        for(int j = 1;j<=n;j++)
    	            w.println(j+" "+i);
    	       flag = 1;
	        }
	        else
	        {
	           for(int j = n;j>0;j--)
	                w.println(j+" "+i);
	           flag = 0;
	        }
	    }

	    for(int i=1;i<y;i++)
	    {
	        if(flag == 0)
	        {
    	        for(int j = 1;j<=n;j++)
    	            w.println(j+" "+i);
    	        flag = 1;
	        }
	        else
	        {
	           for(int j = n;j>0;j--)
	                w.println(j+" "+i);
	            flag = 0;
	        }
	    }

        w.flush();
	    w.close();
	}
}


import java.io.*;
import java.util.*;
import java.math.*;
import java.lang.*;

import static java.lang.Math.*;

public class Cf182 implements Runnable
{
	static class InputReader
	{
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;
		private SpaceCharFilter filter;
		private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		public InputReader(InputStream stream)
		{
			this.stream = stream;
		}

		public int read()
		{
			if (numChars==-1)
				throw new InputMismatchException();

			if (curChar >= numChars)
			{
				curChar = 0;
				try
				{
					numChars = stream.read(buf);
				}
				catch (IOException e)
				{
					throw new InputMismatchException();
				}

				if(numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine()
		{
			String str = "";
			try
			{
				str = br.readLine();
			}
			catch (IOException e)
			{
				e.printStackTrace();
			}
			return str;
		}
		public int nextInt()
		{
			int c = read();

			while(isSpaceChar(c))
				c = read();

			int sgn = 1;

			if (c == '-')
			{
				sgn = -1;
				c = read();
			}

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

			return res * sgn;
		}

		public long nextLong()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			long res = 0;

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

		public double nextDouble()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-')
			{
				sgn = -1;
				c = read();
			}
			double res = 0;
			while (!isSpaceChar(c) && c != '.')
			{
				if (c == 'e' || c == 'E')
					return res * Math.pow(10, nextInt());
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			}
			if (c == '.')
			{
				c = read();
				double m = 1;
				while (!isSpaceChar(c))
				{
					if (c == 'e' || c == 'E')
						return res * Math.pow(10, nextInt());
					if (c < '0' || c > '9')
						throw new InputMismatchException();
					m /= 10;
					res += (c - '0') * m;
					c = read();
				}
			}
			return res * sgn;
		}

		public String readString()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do
			{
				res.appendCodePoint(c);
				c = read();
			}
			while (!isSpaceChar(c));

			return res.toString();
		}

		public boolean isSpaceChar(int c)
		{
			if (filter != null)
				return filter.isSpaceChar(c);
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		public String next()
		{
			return readString();
		}

		public interface SpaceCharFilter
		{
			public boolean isSpaceChar(int ch);
		}
	}
	public static void main(String args[]) throws Exception
	{
		new Thread(null, new Cf182(),"Main",1<<27).start();
	}

	public static long gcd(long a, long b)
	{
		if (a == 0)
			return b;
		return gcd(b % a, a);
	}
	//  array sorting by colm
public static void sortbyColumn(int arr[][], int col)
    {

        Arrays.sort(arr, new Comparator<int[]>() {

          @Override
          public int compare(final int[] entry1,
                             final int[] entry2) {

            if (entry1[col] > entry2[col])
                return 1;
            else
                return -1;
          }
        });
    }

	// gcd

	public static long findGCD(long arr[], int n)
	{
		long result = arr[0];
		for (int i = 1; i < n; i++)
			result = gcd(arr[i], result);
		return result;
	}
	// fibonaci
	static int fib(int n)
    {
        int a = 0, b = 1, c;
        if (n == 0)
            return a;
        for (int i = 2; i <= n; i++)
        {
            c = a + b;
            a = b;
            b = c;
        }
        return b;
    }

// sort a string
    public static String sortString(String inputString)
    {

        char tempArray[] = inputString.toCharArray();

        Arrays.sort(tempArray);

        return new String(tempArray);
    }
    // pair function

    // list.add(new Pair<>(sc.nextInt(), i + 1));
    //     Collections.sort(list, (a, b) -> Integer.compare(b.first, a.first));
    private static class Pair<F, S> {

        private F first;

        private S second;

        public Pair() {}

        public Pair(F first, S second) {
            this.first = first;
            this.second = second;
        }
    }

	// SortedArrayList<Integer> test = new SortedArrayList<Integer>();
    // test.insert(5);
            public static class SortedArrayList<T> extends ArrayList<T> {

            @SuppressWarnings("unchecked")
            public void insert(T value) {
                add(value);
                Comparable<T> cmp = (Comparable<T>) value;
                for (int i = size()-1; i > 0 && cmp.compareTo(get(i-1)) < 0; i--)
                    Collections.swap(this, i, i-1);
            }
        }

	public void run()
	{
		InputReader sc = new InputReader(System.in);
		PrintWriter w = new PrintWriter(System.out);
	    int n = sc.nextInt();
	    int m = sc.nextInt();
	    int x = sc.nextInt();
	    int y = sc.nextInt();

	    for(int i = x;i<=n;i++)
	        w.println(y+" "+i);

	    for(int i=1;i<x;i++)
	        w.println(y+" "+i);

	     int flag = 0;

	    for(int i=y+1;i<=m;i++)
	    {
	        if(flag == 0)
	        {
    	        for(int j = 1;j<=n;j++)
    	            w.println(i+" "+j);
    	       flag = 1;
	        }
	        else
	        {
	           for(int j = n;j>0;j--)
	                w.println(i+" "+j);
	           flag = 0;
	        }
	    }

	    for(int i=1;i<y;i++)
	    {
	        if(flag == 0)
	        {
    	        for(int j = 1;j<=n;j++)
    	            w.println(i+" "+j);
    	        flag = 1;
	        }
	        else
	        {
	           for(int j = n;j>0;j--)
	                w.println(i+" "+j);
	            flag = 0;
	        }
	    }

        w.flush();
	    w.close();
	}
}


import java.io.*;
import java.awt.Rectangle;
import java.util.*;

public class problemA
{
   public static void main (String[] args) throws IOException
   {
      BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
    //BufferedReader input = new BufferedReader(new FileReader("angry.in"));
    //PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("angry.out")));
      StringTokenizer token = new StringTokenizer(input.readLine());
      int rows = Integer.parseInt(token.nextToken());
      int column = Integer.parseInt(token.nextToken());
      int startingX = Integer.parseInt(token.nextToken());
      int startingY = Integer.parseInt(token.nextToken());
      int[][] grid = new int[rows][column];
      for(int x = startingX; x <= grid[startingX].length; x++)
         System.out.println(startingX + " " + x);

      for(int x = startingX - 1; x >= 1; x--)
         System.out.println(startingX + " " + x);

      for(int x = startingY + 1; x <= grid.length; x++)
      {
         System.out.println(x + " " + 1);
      }
      for(int x = startingY - 1; x >= 1; x--)
      {
         System.out.println(x + " " + 1);
      }
      boolean top = true;
      for(int x = 2; x <= grid[startingX].length; x++)
      {
         if(top)
         {
            for(int y = 1; y <= grid.length; y++)
            {
               if(y != startingX)
                  System.out.println(y + " " + x);
            }
            top = false;
         }
         else
         {
            for(int y = grid.length; y >= 1; y--)
            {
               if(y != startingX)
                  System.out.println(y + " " + x);
            }

            top = true;
         }
      }
   }
}


import java.io.*;
import java.awt.Rectangle;
import java.util.*;

public class problemA
{
   public static void main (String[] args) throws IOException
   {
      BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
    //BufferedReader input = new BufferedReader(new FileReader("angry.in"));
    //PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("angry.out")));
      StringTokenizer token = new StringTokenizer(input.readLine());
      int rows = Integer.parseInt(token.nextToken());
      int column = Integer.parseInt(token.nextToken());
      int startingX = Integer.parseInt(token.nextToken());
      int startingY = Integer.parseInt(token.nextToken());
      int[][] grid = new int[rows][column];
      for(int x = startingX; x <= grid[startingX].length; x++)
         System.out.println(startingX + " " + x);

      for(int x = startingX - 1; x >= 1; x--)
         System.out.println(startingX + " " + x);

      for(int x = startingY + 1; x <= grid.length; x++)
      {
         System.out.println(x + " " + 1);
      }
      for(int x = startingY - 1; x >= 1; x--)
      {
         System.out.println(x + " " + 1);
      }
      boolean top = true;
      for(int x = 2; x <= grid[startingX].length; x++)
      {
         if(top)
         {
            for(int y = 1; y <= grid.length; y++)
            {
               if(y != startingY)
                  System.out.println(x + " " + y);
            }
            top = false;
         }
         else
         {
            for(int y = grid.length; y >= 1; y--)
            {
               if(y != startingY)
                  System.out.println(x + " " + y);
            }

            top = true;
         }
      }
   }
}


import java.io.*;
import java.awt.Rectangle;
import java.util.*;

public class problemA
{
   public static void main (String[] args) throws IOException
   {
      BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
    //BufferedReader input = new BufferedReader(new FileReader("angry.in"));
    //PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter("angry.out")));
      StringTokenizer token = new StringTokenizer(input.readLine());
      int rows = Integer.parseInt(token.nextToken());
      int column = Integer.parseInt(token.nextToken());
      int startingX = Integer.parseInt(token.nextToken());
      int startingY = Integer.parseInt(token.nextToken());
      int[][] grid = new int[rows][column];
      for(int x = startingY; x <= grid[startingX].length; x++)
         System.out.println(startingX + " " + x);

      for(int x = startingY - 1; x >= 1; x--)
         System.out.println(startingX + " " + x);

      for(int x = startingX + 1; x <= grid.length; x++)
      {
         System.out.println(x + " " + 1);
      }
      for(int x = startingX - 1; x >= 1; x--)
      {
         System.out.println(x + " " + 1);
      }
      boolean top = true;
      for(int x = 2; x <= grid[startingX].length; x++)
      {
         if(top)
         {
            for(int y = 1; y <= grid.length; y++)
            {
               if(y != startingX)
                  System.out.println(y + " " + x);
            }
            top = false;
         }
         else
         {
            for(int y = grid.length; y >= 1; y--)
            {
               if(y != startingX)
                  System.out.println(y + " " + x);
            }

            top = true;
         }
      }
   }
}


import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.time.LocalTime;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

public class B {

    public static void main(String[] args) {

    	FastScanner scan = new FastScanner();
    	int t = 1;
    	for(int tt=0; tt<t; tt++) {
    		int n = scan.nextInt(), m = scan.nextInt(), startRow = scan.nextInt(), startCol = scan.nextInt();

    		for(int j=startCol-1; j<m; j++) System.out.println(startRow + " " + (j+1));
    		for(int j=startCol-2; j>=0; j--) System.out.println(startRow + " " + (j+1));

    		boolean left = true;
    		int row = startRow - 2;
    		for(int i=row; i>=0; i--) {
    			if(left) {
    				for(int j=0; j<m; j++) System.out.println((i+1) + " " + (j+1));
    				left = false;
    			} else {
    				for(int j=m-1; j>=0; j--) System.out.println((i+1) + " " + (j+1));
    				left = true;
    			}
    		}
    		row = startRow;
    		for(int i=row; i<n; i++) {
    			if(left) {
    				for(int j=0; j<m; j++) System.out.println((i+1) + " " + (j+1));
    				left = false;
    			} else {
    				for(int j=m-1; j>=0; j--) System.out.println((i+1) + " " + (j+1));
    				left = true;
    			}
    		}
    	}
    }

    public static void sort(int [] a) {
    	ArrayList<Integer> b = new ArrayList<>();
    	for(int i: a) b.add(i);
    	Collections.sort(b);
    	for(int i=0; i<a.length; i++) a[i]= b.get(i);
    }

    static class FastScanner{

    	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    	StringTokenizer st = new StringTokenizer("");
    	String next() {
    		while(!st.hasMoreTokens())
    			try {
    				st = new StringTokenizer(br.readLine());
    			} catch (IOException e){
    				e.printStackTrace();
    			}
    		return st.nextToken();
    	}

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

    	int [] readArray(int n) {
    		int [] a = new int[n];
    		for(int i=0; i<n ; i++) a[i] = nextInt();
    		return a;
    	}

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

    }

}


import java.io.*;
import java.math.*;
import java.security.*;
import java.text.*;
import java.time.LocalTime;
import java.util.*;
import java.util.concurrent.*;
import java.util.regex.*;

public class B {

    public static void main(String[] args) {

    	FastScanner scan = new FastScanner();
    	int t = 1;
    	for(int tt=0; tt<t; tt++) {
    		int n = scan.nextInt(), m = scan.nextInt(), startRow = scan.nextInt(), startCol = scan.nextInt();

    		for(int j=startCol-1; j<m; j++) System.out.println(startRow + " " + (j+1));
    		for(int j=startCol-2; j>=0; j--) System.out.println(startRow + " " + (j+1));

    		boolean left = true;
    		int row = startRow - 2;
    		for(int i=row; i>=0; i--) {
    			if(left) {
    				for(int j=0; j<m; j++) System.out.println((row+1) + " " + (j+1));
    				left = false;
    			} else {
    				for(int j=m-1; j>=0; j--) System.out.println((row+1) + " " + (j+1));
    				left = true;
    			}
    		}
    		row = startRow;
    		for(int i=row; i<n; i++) {
    			if(left) {
    				for(int j=0; j<m; j++) System.out.println((row+1) + " " + (j+1));
    				left = false;
    			} else {
    				for(int j=m-1; j>=0; j--) System.out.println((row+1) + " " + (j+1));
    				left = true;
    			}
    		}
    	}
    }

    public static void sort(int [] a) {
    	ArrayList<Integer> b = new ArrayList<>();
    	for(int i: a) b.add(i);
    	Collections.sort(b);
    	for(int i=0; i<a.length; i++) a[i]= b.get(i);
    }

    static class FastScanner{

    	BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    	StringTokenizer st = new StringTokenizer("");
    	String next() {
    		while(!st.hasMoreTokens())
    			try {
    				st = new StringTokenizer(br.readLine());
    			} catch (IOException e){
    				e.printStackTrace();
    			}
    		return st.nextToken();
    	}

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

    	int [] readArray(int n) {
    		int [] a = new int[n];
    		for(int i=0; i<n ; i++) a[i] = nextInt();
    		return a;
    	}

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

    }

}


//package com.example.codeforcecontest;
import java.util.*;
public class BoboniuPlaysChess {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int n=input.nextInt();
        int m=input.nextInt();
        int sx=input.nextInt();
        int sy=input.nextInt();
        boolean[][] visited=new boolean[n][m];

        visited[sx-1][sy-1]=true;
        System.out.println(sx+" "+sy);

        int row=sx-1;
        int col=0;
        boolean flag=false;

        while(row<n){
            if(!flag) {
                for (int j = 0; j < m; j++) {
                    if(!visited[row][j]) {
                        System.out.println((row + 1) + " " + (j + 1));
                        visited[row][j]=true;
                        col=j;
                    }
                }
            }
            row++;
            flag=!flag;
            if(flag && row<n){
                for(int j=m-1;j>=0;j-- ){
                    if(!visited[row][j]){
                        System.out.println((row+1)+" "+(j+1));
                        visited[row][j]=true;
                        col=j;
                    }
                }
            }
        }
        row=0;
        flag= col==0? false:true;
        while(row<sx-1){
            if(!flag){
                for (int j = 0; j < m; j++) {
                    if(!visited[row][j]) {
                        System.out.println((row + 1) + " " + (j + 1));
                        visited[row][j]=true;
                    }
                }
            }
            row++;
            flag=!flag;
            if(flag && row<sx-1){
                for(int j=m-1;j>=0;j-- ){
                    if(!visited[row][j]){
                        System.out.println((row+1)+" "+(j+1));
                        visited[row][j]=true;
                    }
                }
            }
        }

    }
}


//package com.example.codeforcecontest;
import java.util.*;
public class BoboniuPlaysChess {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int n=input.nextInt();
        int m=input.nextInt();
        int sx=input.nextInt();
        int sy=input.nextInt();
        boolean[][] visited=new boolean[n][m];

        visited[sx-1][sy-1]=true;
        System.out.println(sx+" "+sy);

        int row=sx-1;
        int col=0;
        boolean flag=false;

        while(row<n){
            if(!flag) {
                for (int j = 0; j < m; j++) {
                    if(!visited[row][j]) {
                        System.out.println((row + 1) + " " + (j + 1));
                        visited[row][j]=true;
                        col=j;
                    }
                }
                row++;
                flag=!flag;
            }

            if(flag && row<n){
                for(int j=m-1;j>=0;j-- ){
                    if(!visited[row][j]){
                        System.out.println((row+1)+" "+(j+1));
                        visited[row][j]=true;
                        col=j;
                    }
                }
                row++;
                flag=!flag;
            }
        }
        row=0;
        flag= col==0? false:true;
        while(row<sx-1){
            if(!flag){
                for (int j = 0; j < m; j++) {
                    if(!visited[row][j]) {
                        System.out.println((row + 1) + " " + (j + 1));
                        visited[row][j]=true;
                    }
                }
                row++;
                flag=!flag;
            }

            if(flag && row<sx-1){
                for(int j=m-1;j>=0;j-- ){
                    if(!visited[row][j]){
                        System.out.println((row+1)+" "+(j+1));
                        visited[row][j]=true;
                    }
                }
                row++;
                flag=!flag;
            }
        }

    }
}


//package com.example.codeforcecontest;
import java.util.*;
public class BoboniuPlaysChess {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int n=input.nextInt();
        int m=input.nextInt();
        int sx=input.nextInt();
        int sy=input.nextInt();
        boolean[][] visited=new boolean[n][m];

        visited[sx-1][sy-1]=true;
        System.out.println(sx+" "+sy);

        int row=sx-1;
        int col=0;
        boolean flag=false;

        while(row<n){
            if(!flag) {
                for (int j = 0; j < m; j++) {
                    if(!visited[row][j]) {
                        System.out.println((row + 1) + " " + (j + 1));
                        visited[row][j]=true;
                        col=j;
                    }
                }
            }
            row++;
            flag=!flag;
            if(flag){
                for(int j=m-1;j>=0;j-- ){
                    if(!visited[row][j]){
                        System.out.println((row+1)+" "+(j+1));
                        visited[row][j]=true;
                        col=j;
                    }
                }
            }
        }
        row=0;
        flag= col==0? false:true;
        while(row<sx-1){
            if(!flag){
                for (int j = 0; j < m; j++) {
                    if(!visited[row][j]) {
                        System.out.println((row + 1) + " " + (j + 1));
                        visited[row][j]=true;
                    }
                }
            }
            row++;
            flag=!flag;
            if(flag){
                for(int j=m-1;j>=0;j-- ){
                    if(!visited[row][j]){
                        System.out.println((row+1)+" "+(j+1));
                        visited[row][j]=true;
                    }
                }
            }
        }

    }
}


//package com.example.codeforcecontest;
import java.util.*;
public class BoboniuPlaysChess {
    public static void main(String[] args) {
        Scanner input=new Scanner(System.in);
        int n=input.nextInt();
        int m=input.nextInt();
        int sx=input.nextInt();
        int sy=input.nextInt();
        boolean[][] visited=new boolean[n][m];

        visited[sx-1][sy-1]=true;

        int row=sx-1;
        int col=0;
        boolean flag=false;

        while(row<n){
            if(!flag) {
                for (int j = 0; j < m; j++) {
                    if(!visited[row][j]) {
                        System.out.println((row + 1) + " " + (j + 1));
                        visited[row][j]=true;
                        col=j;
                    }
                }
            }
            row++;
            flag=!flag;
            if(flag){
                for(int j=m-1;j>=0;j-- ){
                    if(!visited[row][j]){
                        System.out.println((row+1)+" "+(j+1));
                        visited[row][j]=true;
                        col=j;
                    }
                }
            }
        }
        row=0;
        flag= col==0? false:true;
        while(row<sx-1){
            if(!flag){
                for (int j = 0; j < m; j++) {
                    if(!visited[row][j]) {
                        System.out.println((row + 1) + " " + (j + 1));
                        visited[row][j]=true;
                    }
                }
            }
            row++;
            flag=!flag;
            if(flag){
                for(int j=m-1;j>=0;j-- ){
                    if(!visited[row][j]){
                        System.out.println((row+1)+" "+(j+1));
                        visited[row][j]=true;
                    }
                }
            }
        }

    }
}


import java.util.Scanner;

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
		try {
		    Scanner sc = new Scanner(System.in);
		    int t,n,m,x,y,i,j,a,b;

		        n=sc.nextInt();
		        m=sc.nextInt();
		        x=sc.nextInt();
		        y=sc.nextInt();
		        a=x;
		        b=y;
		        int h=0;
		        while(h < (n*m))
		        {

		            while(x>=1 && ((h < (n*m))))
		            {
		                System.out.println((x)+" "+(y));
		                x--;
		                h++;
		            }
		            x=a+1;
		            while(x<=n && (h < (n*m)))
		            {
		               System.out.println((x)+" "+(y));
		                x++;
		                h++;
		            }
		            if(y>0 && y<=b)
		             y--;
		             else
		             y++;
		             if(y==0)
		              y=b+1;
		             x--;
		             a=n;
		        }

		} catch(Exception e) {
		}
	}
}


import java.util.Scanner;

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
		try {
		    Scanner sc = new Scanner(System.in);
		    int t,n,m,x,y,i,j,a,b;

		        n=sc.nextInt();
		        m=sc.nextInt();
		        x=sc.nextInt();
		        y=sc.nextInt();
		        a=x;
		        b=y;
		        int h=0;
		        //System.out.println(x+" "+y);
		        while(h < (n*m))
		        {

		            while(x>=1 && ((h < (n*m))))
		            {
		                System.out.println((x)+" "+(y));
		                x--;
		                h++;
		            }
		            x=a+1;
		            while(x<=n && (h < (n*m)))
		            {
		               System.out.println((x)+" "+(y));
		                x++;
		                h++;
		            }
		            if(y>1)
		             y--;
		             else
		             y=b+1;
		             x--;
		        }

		} catch(Exception e) {
		}
	}
}


import java.util.Scanner;

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
		try {
		    Scanner sc = new Scanner(System.in);
		    int t,n,m,x,y,i,j,a,b;

		        n=sc.nextInt();
		        m=sc.nextInt();
		        x=sc.nextInt();
		        y=sc.nextInt();
		        a=x;
		        b=y;
		        int h=0;j=i=1;
		       while(h<(n*m))
		       {
		           while(x>=1 && x<=n && h<(n*m) && i==1)
		           {
		               System.out.println(x+" "+y);
		               x--;
		               h++;
		           }
		           x=a+1;
		            while(x>=1 && x<=n && h<(n*m) && j==1)
		           {
		               System.out.println(x+" "+y);
		               x++;
		               h++;
		           }
		           a=0;
		           if(y>=1 && y<=b)
		            y--;
		            else
		            y++;
		            if(y==0)
		            y=b+1;
		            if(x==(n+1))
		             {
		                 j=0;
		                 i=1;
		                 x--;
		             }
		             else
		             {
		                 i=0;
		                 j=1;
		                 x++;
		             }
		       }
		} catch(Exception e) {
		}
	}
}