import java.util.*;
public class Solution {

	public static void main(String [] args)
	{

		Scanner in = new Scanner(System.in);

			int n = in.nextInt();
			int m =in.nextInt();
			int sx =in.nextInt();
			int sy =in.nextInt();

			System.out.println(sx+" "+sy);

			sy--;
			int inY =sy+1;
			while(sy>0)
			{
				System.out.println(sx+" "+sy);
				sy--;
			}
			sy =inY+1;

			while(sy<=m)
			{
				System.out.println(sx+" "+sy);
				sy++;
			}

			sy =m;
			sx--;
			int inx =sx+1;
			while(sx>0)
			{

				int counter =1;
				if(sy==m)
				{
					counter=1;
				}
				else {
					counter=0;
				}

				if(counter%2==1)
				{
					while(sy>0)
					{
						System.out.println(sx+" "+sy);
						sy--;
					}
					sy=1;
					counter=0;
				}
				else {
					while(sy<=m)
					{
						System.out.println(sx+" "+sy);
						sy++;
					}
					sy=m;
					counter=1;
				}
				sx--;

			}
			sx =inx+1;

			while(sx<=n)
			{

				int counter =1;
				if(sy==m)
				{
					counter=1;
				}
				else {
					counter=0;
				}

				if(counter%2==1)
				{
					while(sy>0)
					{
						System.out.println(sx+" "+sy);
						sy--;
					}
					sy=1;
					counter=0;
				}
				else {
					while(sy<=m)
					{
						System.out.println(sx+" "+sy);
						sy++;
					}
					sy=m;
					counter=1;
				}
				sx++;

			}

		}

}


import java.util.*;
public class Solution {

	public static void main(String [] args)
	{

		Scanner in = new Scanner(System.in);

			int n = in.nextInt();
			int m =in.nextInt();
			int sx =in.nextInt();
			int sy =in.nextInt();

			System.out.println(sx+" "+sy);

			sy--;
			int inY =sy+1;
			while(sy>0)
			{
				System.out.println(sx+" "+sy);
				sy--;
			}
			sy =inY+1;

			while(sy<=m)
			{
				System.out.println(sx+" "+sy);
				sy++;
			}

			sy =m;
			sx--;
			int inx =sx+1;
			while(sx>0)
			{

				int counter =1;

				if(counter%2==1)
				{
					while(sy>0)
					{
						System.out.println(sx+" "+sy);
						sy--;
					}
					sy=1;
					counter=0;
				}
				else {
					while(sy<=m)
					{
						System.out.println(sx+" "+sy);
						sy++;
					}
					sy=m;

					counter=1;
				}
				sx--;

			}
			sx =inx+1;

			while(sx<=n)
			{

				int counter =1;
				if(sy==m)
				{
					counter=1;
				}
				else {
					counter=0;
				}

				if(counter%2==1)
				{
					while(sy>0)
					{
						System.out.println(sx+" "+sy);
						sy--;
					}
					sy=1;
					counter=0;
				}
				else {
					while(sy<=m)
					{
						System.out.println(sx+" "+sy);
						sy++;
					}
					sy=m;

					counter=1;
				}
				sx++;

			}

		}

}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

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

    static class BBoboniuPlaysChess {
        int currx;
        int curry;
        int n;
        int m;
        boolean[][] vis;

        boolean moveLeft() {
            if (currx > 1 && !vis[curry][currx - 1]) {
                currx--;
                vis[curry][currx] = true;
                return true;
            }
            return false;
        }

        boolean moveRight() {
            if (currx < m && !vis[curry][currx + 1]) {
                currx++;
                vis[curry][currx] = true;
                return true;
            }
            return false;
        }

        boolean moveup() {
            if (curry > 1 && !vis[curry - 1][currx]) {
                curry--;
                vis[curry][currx] = true;
                return true;
            }
            return false;

        }

        void movedown() {
            if (curry < n && !vis[curry + 1][currx]) {
                vis[curry][currx] = true;
                curry++;
            }
        }

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            n = in.nextInt();
            m = in.nextInt();
            int x = in.nextInt();
            int y = in.nextInt();

            curry = x;
            currx = y;
            vis = new boolean[n + 1][m + 1];
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < n * m; i++) {
                sb.append(curry);
                sb.append(" ");
                sb.append(currx);
                sb.append("\n");

                if (!moveLeft()) {
                    if (!moveup()) {
                        if (!moveRight()) {
                            movedown();
                        }
                    }
                }
            }
            out.println(sb.toString());

        }

    }

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

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

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

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

            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();

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

            int sgn = 1;

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

            int res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();

                res *= 10;
                res += c & 15;

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

            return res * sgn;
        }

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

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

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

    static class BBoboniuPlaysChess {
        int currx;
        int curry;
        int n;
        int m;
        boolean[][] vis;

        boolean moveLeft() {
            if (currx > 1 && !vis[curry][currx - 1]) {
                currx--;
                vis[curry][currx] = true;
                return true;
            }
            return false;
        }

        boolean moveRight() {
            if (currx < m && !vis[curry][currx + 1]) {
                currx++;
                vis[curry][currx] = true;
                return true;
            }
            return false;
        }

        boolean moveup() {
            if (curry > 1 && !vis[curry - 1][currx]) {
                curry--;
                vis[curry][currx] = true;
                return true;
            }
            return false;

        }

        void movedown() {
            if (curry < n && !vis[curry + 1][currx]) {
                vis[curry][currx] = true;
                curry++;
            }
        }

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            n = in.nextInt();
            m = in.nextInt();
            int x = in.nextInt();
            int y = in.nextInt();

            curry = x;
            currx = y;
            vis = new boolean[n + 1][m + 1];
            vis[x][y] = true;
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < n * m; i++) {
                sb.append(curry);
                sb.append(" ");
                sb.append(currx);
                sb.append("\n");

                if (!moveLeft()) {
                    if (!moveup()) {
                        if (!moveRight()) {
                            movedown();
                        }
                    }
                }
            }
            out.println(sb.toString());

        }

    }

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

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

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

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

            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();

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

            int sgn = 1;

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

            int res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();

                res *= 10;
                res += c & 15;

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

            return res * sgn;
        }

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

    }
}


import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

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

    static class BBoboniuPlaysChess {
        int currx;
        int curry;
        int n;
        int m;
        boolean[][] vis;

        int moveLeft() {
            if (currx > 1) {
                currx--;
                if (vis[curry][currx]) {
                    return 1;
                }
                vis[curry][currx] = true;
                return 2;
            }
            return 0;
        }

        int moveRight() {
            if (currx < m) {
                currx++;
                if (vis[curry][currx])
                    return 1;
                vis[curry][currx] = true;
                return 2;
            }
            return 0;
        }

        int moveup() {
            if (curry > 1) {
                curry--;
                if (vis[curry][currx])
                    return 1;
                vis[curry][currx] = true;
                return 2;
            }
            return 0;

        }

        int movedown() {
            if (curry < n) {
                curry++;
                if (vis[curry][currx])
                    return 1;
                vis[curry][currx] = true;
                return 2;
            }
            return 0;
        }

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            n = in.nextInt();
            m = in.nextInt();
            int x = in.nextInt();
            int y = in.nextInt();

            curry = x;
            currx = y;
            vis = new boolean[n + 1][m + 1];
            vis[x][y] = true;
            int count = 0;
            StringBuilder sb = new StringBuilder();
            while (true) {
                sb.append(curry);
                sb.append(" ");
                sb.append(currx);
                sb.append("\n");
                count++;
                if (moveup() != 2) {
                    break;
                }
            }

            while (moveLeft() == 2) {
                sb.append(curry);
                sb.append(" ");
                sb.append(currx);
                sb.append("\n");
                count++;
            }

            boolean first = true;
            int odd = 0;
            while (count != n * m) {
                if (!first) {
                    sb.append(curry);
                    sb.append(" ");
                    sb.append(currx);
                    sb.append("\n");
                    count++;
                }
                first = false;

                int vv = 1;
                while (vv == 1) {
                    if (odd % 2 == 1)
                        vv = moveLeft();
                    else
                        vv = moveRight();
                }
                if (vv == 2) {
                    continue;
                }

                vv = 1;
                while (vv == 1) {
                    vv = movedown();
                    odd++;
                }
            }

            out.println(sb.toString());

        }

    }

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

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

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

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

            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();

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

            int sgn = 1;

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

            int res = 0;

            do {
                if (c < '0' || c > '9')
                    throw new InputMismatchException();

                res *= 10;
                res += c & 15;

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

            return res * sgn;
        }

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

    }
}


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

public class Main {
    int[] mx = {-1,0,1,0};
    int[] my = {0,-1,0,1};
    public static void main(String[] args) throws Exception {
        FastScanner sc = new FastScanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        StringBuilder sb = new StringBuilder();
        int n = sc.nextInt();
        int m = sc.nextInt();
        int sx = sc.nextInt();
        int sy = sc.nextInt();
        int cnt = n*m-1;
        Deque<Point> q = new ArrayDeque<Point>();
        for(int i = sx; i >= 1; i--){
            sb.append(i + " " + sy).append("\n");
        }
        for(int i = sx+1; i <= n; i++){
            sb.append(i + " " + sy).append("\n");
        }
        boolean rev = true;

        for(int j = sy-1; j >= 1; j--){
            for(int i = 1; i <= n; i++){
                if(rev){
                    sb.append((n-i+1) + " " + j).append("\n");
                }else{
                    sb.append(i + " " + j).append("\n");
                }
            }
            rev = rev ? false : true;
        }
        for(int j = sy+1; j <= m; j++){
            for(int i = 1; i <= n; i++){
                if(rev){
                    sb.append((n-i+1) + " " + j).append("\n");
                }else{
                    sb.append(i + " " + j).append("\n");
                }
            }
            rev = rev ? false : true;
        }
        pw.print(sb.toString());
        pw.flush();
    }

    static class GeekInteger {
        public static void save_sort(int[] array) {
            shuffle(array);
            Arrays.sort(array);
        }

        public static int[] shuffle(int[] array) {
            int n = array.length;
            Random random = new Random();
            for (int i = 0, j; i < n; i++) {
                j = i + random.nextInt(n - i);
                int randomElement = array[j];
                array[j] = array[i];
                array[i] = randomElement;
            }
            return array;
        }

    }
}

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

class FastScanner {
    private BufferedReader reader = null;
    private StringTokenizer tokenizer = null;
    public FastScanner(InputStream in) {
        reader = new BufferedReader(new InputStreamReader(in));
        tokenizer = null;
    }

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

    public String nextLine() {
        if (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                return reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken("\n");
    }

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

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

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

    public String[] nextArray(int n) {
        String[] a = new String[n];
        for (int i = 0; i < n; i++)
            a[i] = next();
        return a;
    }

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

    public long[] nextLongArray(int n) {
        long[] a = new long[n];
        for (int i = 0; i < n; i++)
            a[i] = nextLong();
        return a;
    }
}


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

public class Main {
    int[] mx = {-1,0,1,0};
    int[] my = {0,-1,0,1};
    public static void main(String[] args) throws Exception {
        FastScanner sc = new FastScanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        StringBuilder sb = new StringBuilder();
        int n = sc.nextInt();
        int m = sc.nextInt();
        int sx = sc.nextInt();
        int sy = sc.nextInt();
        int cnt = n*m-1;
        Deque<Point> q = new ArrayDeque<Point>();
        for(int i = sx; i >= 1; i--){
            sb.append(i + " " + sy).append("\n");
        }
        for(int i = sx+1; i <= n; i++){
            sb.append(i + " " + sy).append("\n");
        }
        boolean rev = true;

        for(int j = sy-1; j >= 1; j--){
            for(int i = 1; i <= n; i++){
                if(rev){
                    sb.append((n-i+1) + " " + j).append("\n");
                }else{
                    sb.append(i + " " + j).append("\n");
                }
                rev = rev ? false : true;
            }
        }
        for(int j = sy+1; j <= m; j++){
            for(int i = 1; i <= n; i++){
                if(rev){
                    sb.append((n-i+1) + " " + j).append("\n");
                }else{
                    sb.append(i + " " + j).append("\n");
                }
                rev = rev ? false : true;
            }
        }
        /*
        for(int i = 1; i <= n; i++){
            for(int j = sy+1; j <= m; j++){
                if(rev){
                    sb.append((n-i+1) + " " + j).append("\n");
                }else{
                    sb.append(i + " " + j).append("\n");
                }
            }
            rev = rev ? false : true;
        }
        /*
        int jmax = Math.max(m-sy,sy);
            for(int j = 1; j < jmax; j++){
                if(sy+j <= m){
                    for(int i = n; i >= 1; i--){
                        sb.append(i + " " + (sy+j)).append("\n");
                    }
                }
                if(sy-j >= 1){
                    for(int i = 1; i <= n; i++){
                        sb.append(i + " " + (sy-j)).append("\n");
                    }
                }
            }
            */
        pw.print(sb.toString());
        pw.flush();
    }

    static class GeekInteger {
        public static void save_sort(int[] array) {
            shuffle(array);
            Arrays.sort(array);
        }

        public static int[] shuffle(int[] array) {
            int n = array.length;
            Random random = new Random();
            for (int i = 0, j; i < n; i++) {
                j = i + random.nextInt(n - i);
                int randomElement = array[j];
                array[j] = array[i];
                array[i] = randomElement;
            }
            return array;
        }

    }
}

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

class FastScanner {
    private BufferedReader reader = null;
    private StringTokenizer tokenizer = null;
    public FastScanner(InputStream in) {
        reader = new BufferedReader(new InputStreamReader(in));
        tokenizer = null;
    }

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

    public String nextLine() {
        if (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                return reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken("\n");
    }

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

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

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

    public String[] nextArray(int n) {
        String[] a = new String[n];
        for (int i = 0; i < n; i++)
            a[i] = next();
        return a;
    }

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

    public long[] nextLongArray(int n) {
        long[] a = new long[n];
        for (int i = 0; i < n; i++)
            a[i] = nextLong();
        return a;
    }
}


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

public class Main {
    int[] mx = {-1,0,1,0};
    int[] my = {0,-1,0,1};
    public static void main(String[] args) throws Exception {
        FastScanner sc = new FastScanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);
        StringBuilder sb = new StringBuilder();
        int n = sc.nextInt();
        int m = sc.nextInt();
        int sx = sc.nextInt();
        int sy = sc.nextInt();
        int cnt = n*m-1;
        Deque<Point> q = new ArrayDeque<Point>();
        for(int i = sx; i >= 1; i--){
            sb.append(i + " " + sy).append("\n");
        }
        for(int i = sx+1; i <= n; i++){
            sb.append(i + " " + sy).append("\n");
        }
        for(int i = 1; i <= n; i++){
            for(int j = sy-1; j >= 1; j--){
                sb.append(i + " " + j).append("\n");
            }
            for(int j = sy+1; j <= m; j++){
                sb.append(i + " " + j).append("\n");
            }
        }
        pw.print(sb.toString());
        pw.flush();
    }

    static class GeekInteger {
        public static void save_sort(int[] array) {
            shuffle(array);
            Arrays.sort(array);
        }

        public static int[] shuffle(int[] array) {
            int n = array.length;
            Random random = new Random();
            for (int i = 0, j; i < n; i++) {
                j = i + random.nextInt(n - i);
                int randomElement = array[j];
                array[j] = array[i];
                array[i] = randomElement;
            }
            return array;
        }

    }
}

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

class FastScanner {
    private BufferedReader reader = null;
    private StringTokenizer tokenizer = null;
    public FastScanner(InputStream in) {
        reader = new BufferedReader(new InputStreamReader(in));
        tokenizer = null;
    }

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

    public String nextLine() {
        if (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                return reader.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken("\n");
    }

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

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

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

    public String[] nextArray(int n) {
        String[] a = new String[n];
        for (int i = 0; i < n; i++)
            a[i] = next();
        return a;
    }

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

    public long[] nextLongArray(int n) {
        long[] a = new long[n];
        for (int i = 0; i < n; i++)
            a[i] = nextLong();
        return a;
    }
}


import java.util.*;

/* Name of the class has to be "Main" only if the class is public. */
public class aaa
{
public static void main (String[] args) throws java.lang.Exception
	{
	    Scanner sc=new Scanner(System.in);
//  int t=Integer.parseInt(sc.nextLine());
//  while(t-->0)
// {
//String s[]=sc.nextLine().split(" ");//sc.nextInt();
//int n=Integer.parseInt(s[0]);
//int k=Integer.parseInt(s[1]);

int m=sc.nextInt();
int n=sc.nextInt();
int sr=sc.nextInt();
int scc=sc.nextInt();int d=0;
System.out.println(m+" "+n+" "+sr+" "+scc);
System.out.println(sr+" "+scc);
for(int i=1;i<=m;i++)
{
    if(i!=sr)
    System.out.println(i+" "+scc);
}
for(int c=1;c<=n;c++)
{
    if(c!=scc)
   {
        if(d==0)
        {
            for(int r=m;r>=1;r--)
          {
            System.out.println(r+" "+c);
          }
          d=1;
        }
        else if(d==1)
        {
        for(int r=1;r<=m;r++)
        System.out.println(r+" "+c);
        d=0;
        }
   }
}
//}	//while
}//public
}//class


import java.util.*;

/* Name of the class has to be "Main" only if the class is public. */
public class aaa
{
public static void main (String[] args) throws java.lang.Exception
	{
	    Scanner sc=new Scanner(System.in);
//  int t=Integer.parseInt(sc.nextLine());
//  while(t-->0)
// {
//String s[]=sc.nextLine().split(" ");//sc.nextInt();
//int n=Integer.parseInt(s[0]);
//int k=Integer.parseInt(s[1]);

int m=sc.nextInt();
int n=sc.nextInt();
int sr=sc.nextInt();
int scc=sc.nextInt();int d=0;
//System.out.println(m+" "+n+" "+sr+" "+scc);
System.out.println(sr+" "+scc);
for(int i=1;i<=m;i++)
{
    if(i!=sr)
    System.out.println(i+" "+scc);
}
for(int c=1;c<=n;c++)
{
    if(c!=scc)
   {
        if(d==0)
        {
            for(int r=m;r>=1;r--)
          {
            System.out.println(r+" "+c);
          }
          d=1;
        }
        else if(d==1)
        {
        for(int r=1;r<=m;r++)
        System.out.println(r+" "+c);
        d=0;
        }
   }
}
//}	//while
}//public
}//class


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

 public class Task{
// taking inputs
static BufferedReader s1;
static BufferedWriter out;
static String read() throws IOException{String line="";while(line.length()==0){line=s1.readLine();continue;}return line;}
static int int_v (String s1){return Integer.parseInt(s1);}
static long long_v(String s1){return Long.parseLong(s1);}
static int[] int_arr() throws IOException{String[] a=read().split(" ");int[] b=new int[a.length];for(int i=0;i<a.length;i++){b[i]=int_v(a[i]);}return b;}
static long[] long_arr() throws IOException{String[] a=read().split(" ");long[] b=new long[a.length];for(int i=0;i<a.length;i++){b[i]=long_v(a[i]);}return b;}
static void assign(){s1=new BufferedReader(new InputStreamReader(System.in));out=new BufferedWriter(new OutputStreamWriter(System.out));}
static long Modpow(long a,long p,long m){long res=1;while(p>0){if((p&1)!=0){res=(res*a)%m;}p >>=1;a=(a*a)%m;}return res;}
static long Modmul(long a,long b,long m){return ((a%m)*(b%m))%m;}
static long ModInv(long a,long m){return Modpow(a,m-2,m);}
static long mod=(long)1e9+7;
//sort map w.r.t value use-> TreeSet of array? write comparator which depends on all the entries of array otherwise weired behavior you can prove it.
//......................................@uthor_Alx..............................................
// vikassingh@maths.iitd.ac.in
static long[] f;
   public static void main(String[] args) throws  IOException{
                assign();
                int t=1;//int_v(read()),cn=1;
                while(t--!=0){
                    int[] x=int_arr();
                    int n=x[0],m=x[1],sx=x[2],sy=x[3];
                    List<int[]> l=new ArrayList<>();
                    l.add(new int[]{sx,sy});
                    for(int i=sy-1;i>=1;i--){l.add(new int[]{sx,i});}
                    for(int i=sy+1;i<=m;i++){l.add(new int[]{sx,i});}
                        int j=sx-1; int f=-1;
                        while(j>=1){
                             f=-1;
                           for(int i=m;i>=1;i--){
                                l.add(new int[]{j,i});
                           }
                           j--;f=1;
                           if(j<=0) break;
                           for(int i=1;i<=m;i++){
                                l.add(new int[]{j,i});
                           }
                           j--;
                        }
                        if(n>sx){
                             j=sx+1;
                        while(j<=n){
                          if(f==1){
                             for(int i=1;i<=m;i++){
                                l.add(new int[]{j,i});
                           }
                          }
                          else{
                            for(int i=m;i>=1;i--){
                                l.add(new int[]{j,i});
                           }
                          }
                           j++;f*=-1;
                           if(j>n) break;
                           if(f==1){
                             for(int i=1;i<=m;i++){
                                l.add(new int[]{j,i});
                           }
                          }
                          else{
                            for(int i=m;i>=1;i--){
                                l.add(new int[]{j,i});
                           }
                          }
                           j++;f*=-1;
                        }
                        }
                    for(int[] z:l){
                        out.write(z[0]+" "+z[1]+"\n");
                    }
                }

                out.flush();

    }
}


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

 public class Task{
// taking inputs
static BufferedReader s1;
static BufferedWriter out;
static String read() throws IOException{String line="";while(line.length()==0){line=s1.readLine();continue;}return line;}
static int int_v (String s1){return Integer.parseInt(s1);}
static long long_v(String s1){return Long.parseLong(s1);}
static int[] int_arr() throws IOException{String[] a=read().split(" ");int[] b=new int[a.length];for(int i=0;i<a.length;i++){b[i]=int_v(a[i]);}return b;}
static long[] long_arr() throws IOException{String[] a=read().split(" ");long[] b=new long[a.length];for(int i=0;i<a.length;i++){b[i]=long_v(a[i]);}return b;}
static void assign(){s1=new BufferedReader(new InputStreamReader(System.in));out=new BufferedWriter(new OutputStreamWriter(System.out));}
static long Modpow(long a,long p,long m){long res=1;while(p>0){if((p&1)!=0){res=(res*a)%m;}p >>=1;a=(a*a)%m;}return res;}
static long Modmul(long a,long b,long m){return ((a%m)*(b%m))%m;}
static long ModInv(long a,long m){return Modpow(a,m-2,m);}
static long mod=(long)1e9+7;
//sort map w.r.t value use-> TreeSet of array? write comparator which depends on all the entries of array otherwise weired behavior you can prove it.
//......................................@uthor_Alx..............................................
// vikassingh@maths.iitd.ac.in
static long[] f;
   public static void main(String[] args) throws  IOException{
                assign();
                int t=1;//int_v(read()),cn=1;
                while(t--!=0){
                    int[] x=int_arr();
                    int n=x[0],m=x[1],sx=x[2],sy=x[3];
                    List<int[]> l=new ArrayList<>();
                    l.add(new int[]{sx,sy});
                    for(int i=sy-1;i>=1;i--){l.add(new int[]{sx,i});}
                    for(int i=sy+1;i<=m;i++){l.add(new int[]{sx,i});}
                        int j=sx-1; int f=-1;
                        while(j>=1){
                             f=-1;
                           for(int i=m;i>=1;i--){
                                l.add(new int[]{j,i});
                           }
                           j--;f=1;
                           if(j<=0) break;
                           for(int i=1;i<=m;i++){
                                l.add(new int[]{j,i});
                           }
                           j--;
                        }
                        if(n>sx){
                             j=sx+1;
                        while(j<=n){
                          if(f==1){
                             for(int i=1;i<=m;i++){
                                l.add(new int[]{j,i});
                           }
                          }
                          else{
                            for(int i=m;i>=1;i--){
                                l.add(new int[]{j,i});
                           }
                          }
                           j++;f*=-1;
                           if(j>n) break;
                           if(f==1){
                             for(int i=1;i<=m;i++){
                                l.add(new int[]{j,i});
                           }
                          }
                          else{
                            for(int i=m;i>=1;i--){
                                l.add(new int[]{j,i});
                           }
                          }
                           j++;
                        }
                        }
                    for(int[] z:l){
                        out.write(z[0]+" "+z[1]+"\n");
                    }
                }

                out.flush();

    }
}


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

 public class Task{
// taking inputs
static BufferedReader s1;
static BufferedWriter out;
static String read() throws IOException{String line="";while(line.length()==0){line=s1.readLine();continue;}return line;}
static int int_v (String s1){return Integer.parseInt(s1);}
static long long_v(String s1){return Long.parseLong(s1);}
static int[] int_arr() throws IOException{String[] a=read().split(" ");int[] b=new int[a.length];for(int i=0;i<a.length;i++){b[i]=int_v(a[i]);}return b;}
static long[] long_arr() throws IOException{String[] a=read().split(" ");long[] b=new long[a.length];for(int i=0;i<a.length;i++){b[i]=long_v(a[i]);}return b;}
static void assign(){s1=new BufferedReader(new InputStreamReader(System.in));out=new BufferedWriter(new OutputStreamWriter(System.out));}
static long Modpow(long a,long p,long m){long res=1;while(p>0){if((p&1)!=0){res=(res*a)%m;}p >>=1;a=(a*a)%m;}return res;}
static long Modmul(long a,long b,long m){return ((a%m)*(b%m))%m;}
static long ModInv(long a,long m){return Modpow(a,m-2,m);}
static long mod=(long)1e9+7;
//sort map w.r.t value use-> TreeSet of array? write comparator which depends on all the entries of array otherwise weired behavior you can prove it.
//......................................@uthor_Alx..............................................
// vikassingh@maths.iitd.ac.in
static long[] f;
   public static void main(String[] args) throws  IOException{
                assign();
                int t=1;//int_v(read()),cn=1;
                while(t--!=0){
                    int[] x=int_arr();
                    int n=x[0],m=x[1],sx=x[2],sy=x[3];
                    List<int[]> l=new ArrayList<>();
                    l.add(new int[]{sx,sy});
                    for(int i=sy-1;i>=1;i--){l.add(new int[]{sx,i});}
                    for(int i=sy+1;i<=m;i++){l.add(new int[]{sx,i});}
                        int j=sx-1; int f=-1;
                        while(j>=1){
                           for(int i=m;i>=1;i--){
                                l.add(new int[]{j,i});
                           }
                           j--;f=1;
                           if(j<=0) break;
                           for(int i=1;i<=m;i++){
                                l.add(new int[]{j,i});
                           }
                           f*=-1;
                           j--;
                        }
                        if(n>sx){
                             j=sx+1;
                        while(j<=n){
                          if(f==1){
                             for(int i=1;i<=m;i++){
                                l.add(new int[]{j,i});
                           }
                          }
                          else{
                            for(int i=m;i>=1;i--){
                                l.add(new int[]{j,i});
                           }
                          }
                           j++;f*=-1;
                           if(j>n) break;
                           if(f==1){
                             for(int i=1;i<=m;i++){
                                l.add(new int[]{j,i});
                           }
                          }
                          else{
                            for(int i=m;i>=1;i--){
                                l.add(new int[]{j,i});
                           }
                          }
                           j++;f*=-1;
                        }
                        }
                    for(int[] z:l){
                        out.write(z[0]+" "+z[1]+"\n");
                    }
                }

                out.flush();

    }
}


/* package codechef; // don't place package name! */

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

public class chef {

	public static void main(String[] args) throws java.lang.Exception {
		Scanner s = new Scanner(System.in);
		int t = s.nextInt();
		while (t-- > 0) {
			int n = s.nextInt();
			int m = s.nextInt();
			int x = s.nextInt();
			int y = s.nextInt();
			int count = 0;
			boolean[][] visited = new boolean[n + 1][m + 1];
			int total = n * m;
			boolean down = true;
			int x1 = x, y1 = y;
			while (count < m) {
				visited[x1][y1] = true;
				System.out.println(x1 + " " + y1);
				if (y1 == 1) {
					down = !down;
					y1 = y;
				}
				y1 = down ? y1 - 1 : y1 + 1;
				count++;
			}
//			System.out.println(count);
			down = true;

			while (m > 0 && count != total) {
				int i = 1;
				y1 = m;
				while (i != n + 1) {

					if (visited[i][y1]) {
						i++;
						continue;
					} else
						visited[i][y1] = true;

					System.out.println(i + " " + y1);
					i++;

					count++;
				}
				if (count == total)
					break;
				m--;
				y1 = m;
				i=n;
				while (i > 0) {
					if (visited[i][y1]) {
						i--;
						continue;
					} else
						visited[i][y1] = true;
					System.out.println(i + " " + y1);
					i--;
					count++;
				}
				if (count == total)
					break;
				m--;

			}
		}
	}
}
//			long r = s.nextLong();
//			long g = s.nextLong();
//			long b = s.nextLong();
//			long w = s.nextLong();
//			int odd = 0;
//			int even = 0;
//
//			if (w != 0 && (r == 0 || g == 0 || b == 0)) {
//				if (r % 2 == 0 && r != 0)
//					even++;
//
//				if (g % 2 == 0 && g != 0)
//					even++;
//
//				if (b % 2 == 0 && b != 0)
//					even++;
//
//				if (even >= 2)
//					System.out.println("Yes");
//				else
//					System.out.println("No");
//
//			} else {
//				if (r % 2 == 0)
//					even++;
//				else
//					odd++;
//
//				if (g % 2 == 0)
//					even++;
//				else
//					odd++;
//
//				if (b % 2 == 0)
//					even++;
//				else
//					odd++;
//
//				if (w % 2 == 0 && even == 1 && odd == 2) {
//					System.out.println("No");
//				} else if (w % 2 != 0 && even == 2 && odd == 1) {
//					System.out.println("No");
//				} else {
//					System.out.println("Yes");
//				}
//			}
//
//		}
//	}
//}


/* package codechef; // don't place package name! */

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

public class chef {

	public static void main(String[] args) throws java.lang.Exception {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		int m = s.nextInt();
		int x = s.nextInt();
		int y = s.nextInt();
		int count = 0;
		boolean[][] visited = new boolean[n + 1][m + 1];
		int total = n * m;
		boolean down = true;
		int x1 = x, y1 = y;
		while (count < m) {
			visited[x1][y1] = true;
			System.out.println(x1 + " " + y1);
			if (y1 == 1) {
				down = !down;
				y1 = y;
			}
			y1 = down ? y1 - 1 : y1 + 1;
			count++;
		}
//			System.out.println(count);
		down = true;

		while (m > 0 && count != total) {
			int i = 1;
			y1 = m;
			while (i != n + 1) {

				if (visited[i][y1]) {
					i++;
					continue;
				} else
					visited[i][y1] = true;

				System.out.println(i + " " + y1);
				i++;

				count++;
			}
			if (count == total)
				break;
			m--;
			y1 = m;
			i = n;
			while (i > 0) {
				if (visited[i][y1]) {
					i--;
					continue;
				} else
					visited[i][y1] = true;
				System.out.println(i + " " + y1);
				i--;
				count++;
			}
			if (count == total)
				break;
			m--;

		}
	}
}

//			long r = s.nextLong();
//			long g = s.nextLong();
//			long b = s.nextLong();
//			long w = s.nextLong();
//			int odd = 0;
//			int even = 0;
//
//			if (w != 0 && (r == 0 || g == 0 || b == 0)) {
//				if (r % 2 == 0 && r != 0)
//					even++;
//
//				if (g % 2 == 0 && g != 0)
//					even++;
//
//				if (b % 2 == 0 && b != 0)
//					even++;
//
//				if (even >= 2)
//					System.out.println("Yes");
//				else
//					System.out.println("No");
//
//			} else {
//				if (r % 2 == 0)
//					even++;
//				else
//					odd++;
//
//				if (g % 2 == 0)
//					even++;
//				else
//					odd++;
//
//				if (b % 2 == 0)
//					even++;
//				else
//					odd++;
//
//				if (w % 2 == 0 && even == 1 && odd == 2) {
//					System.out.println("No");
//				} else if (w % 2 != 0 && even == 2 && odd == 1) {
//					System.out.println("No");
//				} else {
//					System.out.println("Yes");
//				}
//			}
//
//		}
//	}
//}


import java.awt.*;
import java.io.*;

import java.math.BigInteger;
import java.util.*;

public class TaskC {

    static class Edge implements Comparable<Edge> {
        int v,cost;

        public Edge( int x, int y) {
            this.v = x;
            this.cost = y;
        }

        public int compareTo(Edge o) {
            if (cost  == o.cost)
                return v - o.v;
            return v - o.v;
        }

        @Override
        public boolean equals(Object o) {
            Edge edge = (Edge) o;
            return v == edge.v &&
                   cost == edge.cost;
        }

        public String toString() {
            return  v+" "+ cost;
        }
    }
    static int n,h;
    static long sum = 0;
    static ArrayList<Edge>[]adjList;
    static int reaches;
    static boolean[]vis;
    static HashSet<Integer> set;

    static void dfs(int u ,int v, int c)
    {
        vis[u] = true;
        if(u == v)
        {
            set.add(c);
            vis[u] = false;
            return;
        }
        for (Edge e : adjList[u])
        {
            if(c == -1)
                dfs(e.v , v , e.cost);
            else if(!vis[e.v] && e.cost == c)
                dfs(e.v , v , c);
        }
        if(c != -1)
            vis[u] = false;
    }

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

        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);

        int t = sc.nextInt();
        while (t-->0) {

            int[] arr = new int[]{sc.nextInt(), sc.nextInt(), sc.nextInt(), sc.nextInt()};

            int e = 0;
            int o = 0;
            for (int i = 0; i < 4; i++) {
                if (arr[i] % 2 == 0)
                    e++;
                else
                    o++;
            }
            if (e == 4 || e == 3) {
                pw.println("Yes");
                continue;
            }
            int neg = 0;
            e = 0;
            o = 0;
            for (int i = 0 ; i < 3 ; i++)
            {
                arr[i]--;
                if(arr[i] < 0)
                    neg++;
                if(arr[i]%2==0)e++;
                else o++;
            }
            arr[3]+=3;
            e+=(arr[3]%2 == 0)?1:0;
            if(neg > 0)
                pw.println("No");
            else
            {
                if(e == 3 || e == 4)
                    pw.println("Yes");
                else
                    pw.println("No");
            }
        }
        pw.close();
    }
    static class Point implements Comparable<Point>
    {
        int x ,y , idx;

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

        @Override
        public int compareTo(Point o) {
            if (x == o.x) {
                if (y == o.y)
                    return idx - o.idx;
                return y - o.y;
            }
            return x - o.x;
        }

        @Override
        public String toString() {
            return "Point{" +
                    "x=" + x +
                    ", y=" + y +
                    ", idx=" + idx +
                    '}';
        }
    }

    static class Circle implements Comparable<Circle>
    {
        int x , radius;
        public Circle(int x , int r)
        {
            this.x = x;
            this.radius = r;
        }

        public boolean isInside(Point p)
        {
            return Math.sqrt((p.x - x)*(p.x - x) + (p.y)*(p.y)) <= radius;
        }

        @Override
        public String toString() {
            return "Circle{" +
                    "x=" + x +
                    ", radius=" + radius +
                    '}';
        }

        @Override
        public int compareTo(Circle o) {
            return x - o.x;
        }
    }

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

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

    private  static int dis(int xa , int ya , int xb , int yb)
    {
        return (xa-xb)*(xa - xb) + (ya- yb)*(ya-yb);
    }

    static class Pair implements Comparable<Pair> {
        int x,y;

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

        public int compareTo(Pair o) {
            if (y  == o.y)
                return x - o.x;
            return y - o.y;

        }

        public double dis(Pair a){

            return (a.x - x)*(a.x - x) + (a.y-y)*(a.y-y);
        }

        public String toString() {
            return  x+" "+ y;
        }
        public boolean overlap(Pair a)
        {
            if((this.x >= a.x && this.x <= a.y) || (a.x >= this.x && a.x <= this.y)) return true;
            return false;

        }
    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

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

        public boolean check() {
            if (!st.hasMoreTokens())
                return false;
            return true;
        }

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

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

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

        public double nextDouble() {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if (x.charAt(0) == '-') {
                neg = true;
                start++;
            }
            for (int i = start; i < x.length(); i++)
                if (x.charAt(i) == '.') {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                } else {
                    sb.append(x.charAt(i));
                    if (dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg ? -1 : 1);
        }

        public boolean ready() {
            try {
                return br.ready();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}


import java.awt.*;
import java.io.*;

import java.math.BigInteger;
import java.util.*;

public class TaskC {

    static class Edge implements Comparable<Edge> {
        int v,cost;

        public Edge( int x, int y) {
            this.v = x;
            this.cost = y;
        }

        public int compareTo(Edge o) {
            if (cost  == o.cost)
                return v - o.v;
            return v - o.v;
        }

        @Override
        public boolean equals(Object o) {
            Edge edge = (Edge) o;
            return v == edge.v &&
                   cost == edge.cost;
        }

        public String toString() {
            return  v+" "+ cost;
        }
    }
    static long sum = 0;
    static ArrayList<Edge>[]adjList;
    static int reaches;
    static boolean[]vis;
    static HashSet<Integer> set;

    static char[][] grid;
    static int R, C;
    static int[] dx = new int[]{-1, 1, 0, 0};
    static int[] dy = new int[]{0, 0, -1, 1};
    static boolean[]visited;

    static boolean valid(int i, int j , int R1 , int C1)
    {
        return i != -1 && j != -1 && i != R1 && j != C1;
    }

    static Queue<Point> bfs(int n, int m , int s1 , int s2)
    {
        Queue<Point> q = new LinkedList<Point>();
        q.add(new Point(s1 , s2));
        boolean visited [][] = new boolean[n][m];
        visited[s1][s2] = true;
        Queue<Point> ans = new LinkedList<>();
        while(!q.isEmpty())
        {
            Point p = q.poll();
            ans.add(p);
            for (int i = 0 ; i < dx.length; i++)
            {
                int x = p.x + dx[i], y = p.y + dy[i];
                if(valid(x , y , n , m) && !visited[x][y])
                {
                    visited[x][y] = true;
                    q.add(new Point(x,y));

                }
            }

        }
        return ans;
    }

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

        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);

        int n = sc.nextInt();
        int m = sc.nextInt();
        int s1 = sc.nextInt() - 1 ;
        int s2 = sc.nextInt() - 1;

        Queue<Point> ans = bfs(n,m , s1,s2);
        while (!ans.isEmpty())
            pw.println((ans.peek().x+1) +" "+(ans.poll().y+1) );
        pw.close();
    }
    static class Point implements Comparable<Point>
    {
        int x ,y ;

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

        @Override
        public int compareTo(Point o) {
            if (x == o.x) {
                return y - o.y;
            }
            return x - o.x;
        }

        @Override
        public String toString() {
            return "Point{" +
                    "x=" + x +
                    ", y=" + y +
                    '}';
        }
    }

    static class Circle implements Comparable<Circle>
    {
        int x , radius;
        public Circle(int x , int r)
        {
            this.x = x;
            this.radius = r;
        }

        public boolean isInside(Point p)
        {
            return Math.sqrt((p.x - x)*(p.x - x) + (p.y)*(p.y)) <= radius;
        }

        @Override
        public String toString() {
            return "Circle{" +
                    "x=" + x +
                    ", radius=" + radius +
                    '}';
        }

        @Override
        public int compareTo(Circle o) {
            return x - o.x;
        }
    }

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

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

    private  static int dis(int xa , int ya , int xb , int yb)
    {
        return (xa-xb)*(xa - xb) + (ya- yb)*(ya-yb);
    }

    static class Pair implements Comparable<Pair> {
        int x,y;

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

        public int compareTo(Pair o) {
            if (y  == o.y)
                return x - o.x;
            return y - o.y;

        }

        public double dis(Pair a){

            return (a.x - x)*(a.x - x) + (a.y-y)*(a.y-y);
        }

        public String toString() {
            return  x+" "+ y;
        }
        public boolean overlap(Pair a)
        {
            if((this.x >= a.x && this.x <= a.y) || (a.x >= this.x && a.x <= this.y)) return true;
            return false;

        }
    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

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

        public boolean check() {
            if (!st.hasMoreTokens())
                return false;
            return true;
        }

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

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

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

        public double nextDouble() {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if (x.charAt(0) == '-') {
                neg = true;
                start++;
            }
            for (int i = start; i < x.length(); i++)
                if (x.charAt(i) == '.') {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                } else {
                    sb.append(x.charAt(i));
                    if (dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg ? -1 : 1);
        }

        public boolean ready() {
            try {
                return br.ready();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}


import java.awt.*;
import java.io.*;

import java.math.BigInteger;
import java.util.*;

public class TaskC {

    static class Edge implements Comparable<Edge> {
        int v,cost;

        public Edge( int x, int y) {
            this.v = x;
            this.cost = y;
        }

        public int compareTo(Edge o) {
            if (cost  == o.cost)
                return v - o.v;
            return v - o.v;
        }

        @Override
        public boolean equals(Object o) {
            Edge edge = (Edge) o;
            return v == edge.v &&
                   cost == edge.cost;
        }

        public String toString() {
            return  v+" "+ cost;
        }
    }
    static long sum = 0;
    static ArrayList<Edge>[]adjList;
    static int reaches;
    static boolean[]vis;
    static HashSet<Integer> set;

    static char[][] grid;
    static int R, C;
    static int[] dx = new int[]{-1, 1, 0, 0};
    static int[] dy = new int[]{0, 0, -1, 1};
    static boolean[]visited;

    static boolean valid(int i, int j , int R1 , int C1)
    {
        return i != -1 && j != -1 && i != R1 && j != C1;
    }

    static Queue<Point> bfs(int n, int m , int s1 , int s2)
    {
        Queue<Point> q = new LinkedList<Point>();
        q.add(new Point(s1 , s2));
        boolean visited [][] = new boolean[n][m];
        visited[s1][s2] = true;
        Queue<Point> ans = new LinkedList<>();
        while(!q.isEmpty())
        {
            Point p = q.poll();
            ans.add(p);
            for (int i = 0 ; i < dx.length; i++)
            {
                int x = p.x + dx[i], y = p.y + dy[i];
                if(valid(x , y , n , m) && !visited[x][y])
                {
                    visited[x][y] = true;
                    q.add(new Point(x,y));

                }
            }

        }
        return ans;
    }

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

        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);

        int n = sc.nextInt();
        int m = sc.nextInt();
        int s1 = sc.nextInt();
        int s2 = sc.nextInt();

        for (int j = s2; j <=m ; j++)
            pw.println(s1 + " "+j);
        for (int j = s2 - 1 ; j >= 1 ; j--)
            pw.println(s1 + " "+j);

        boolean f = false;
        for (int i = s1 - 1 ; i >= 1 ; i--) {

            for (int j = f ? m : 1; (f ? j >= 1 : j <= m); ) {
                 pw.println(i + " "+j);
                 if(f)
                     j--;
                 else
                     j++;
            }
            f=!f;
        }

        f = false;
        for (int i = s1 + 1 ; i <= n ; i++) {

            for (int j = f ? m : 1; (f ? j >= 1 : j <= m); ) {
                pw.println(i + " "+j);
                if(f)
                    j--;
                else
                    j++;
            }
            f=!f;
        }

        pw.close();
    }
    static class Point implements Comparable<Point>
    {
        int x ,y ;

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

        @Override
        public int compareTo(Point o) {
            if (x == o.x) {
                return y - o.y;
            }
            return x - o.x;
        }

        @Override
        public String toString() {
            return "Point{" +
                    "x=" + x +
                    ", y=" + y +
                    '}';
        }
    }

    static class Circle implements Comparable<Circle>
    {
        int x , radius;
        public Circle(int x , int r)
        {
            this.x = x;
            this.radius = r;
        }

        public boolean isInside(Point p)
        {
            return Math.sqrt((p.x - x)*(p.x - x) + (p.y)*(p.y)) <= radius;
        }

        @Override
        public String toString() {
            return "Circle{" +
                    "x=" + x +
                    ", radius=" + radius +
                    '}';
        }

        @Override
        public int compareTo(Circle o) {
            return x - o.x;
        }
    }

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

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

    private  static int dis(int xa , int ya , int xb , int yb)
    {
        return (xa-xb)*(xa - xb) + (ya- yb)*(ya-yb);
    }

    static class Pair implements Comparable<Pair> {
        int x,y;

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

        public int compareTo(Pair o) {
            if (y  == o.y)
                return x - o.x;
            return y - o.y;

        }

        public double dis(Pair a){

            return (a.x - x)*(a.x - x) + (a.y-y)*(a.y-y);
        }

        public String toString() {
            return  x+" "+ y;
        }
        public boolean overlap(Pair a)
        {
            if((this.x >= a.x && this.x <= a.y) || (a.x >= this.x && a.x <= this.y)) return true;
            return false;

        }
    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

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

        public boolean check() {
            if (!st.hasMoreTokens())
                return false;
            return true;
        }

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

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

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

        public double nextDouble() {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if (x.charAt(0) == '-') {
                neg = true;
                start++;
            }
            for (int i = start; i < x.length(); i++)
                if (x.charAt(i) == '.') {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                } else {
                    sb.append(x.charAt(i));
                    if (dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg ? -1 : 1);
        }

        public boolean ready() {
            try {
                return br.ready();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}


import java.awt.*;
import java.io.*;

import java.math.BigInteger;
import java.util.*;

public class TaskC {

    static class Edge implements Comparable<Edge> {
        int v,cost;

        public Edge( int x, int y) {
            this.v = x;
            this.cost = y;
        }

        public int compareTo(Edge o) {
            if (cost  == o.cost)
                return v - o.v;
            return v - o.v;
        }

        @Override
        public boolean equals(Object o) {
            Edge edge = (Edge) o;
            return v == edge.v &&
                    cost == edge.cost;
        }

        public String toString() {
            return  v+" "+ cost;
        }
    }
    static long sum = 0;
    static ArrayList<Edge>[]adjList;
    static int reaches;
    static boolean[]vis;
    static HashSet<Integer> set;

    static char[][] grid;
    static int R, C;
    static int[] dx = new int[]{-1, 1, 0, 0};
    static int[] dy = new int[]{0, 0, -1, 1};
    static boolean[]visited;

    static boolean valid(int i, int j , int R1 , int C1)
    {
        return i != -1 && j != -1 && i != R1 && j != C1;
    }

    static Queue<Point> bfs(int n, int m , int s1 , int s2)
    {
        Queue<Point> q = new LinkedList<Point>();
        q.add(new Point(s1 , s2));
        boolean visited [][] = new boolean[n][m];
        visited[s1][s2] = true;
        Queue<Point> ans = new LinkedList<>();
        while(!q.isEmpty())
        {
            Point p = q.poll();
            ans.add(p);
            for (int i = 0 ; i < dx.length; i++)
            {
                int x = p.x + dx[i], y = p.y + dy[i];
                if(valid(x , y , n , m) && !visited[x][y])
                {
                    visited[x][y] = true;
                    q.add(new Point(x,y));

                }
            }

        }
        return ans;
    }

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

        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);

        int n = sc.nextInt();
        int m = sc.nextInt();
        int s1 = sc.nextInt();
        int s2 = sc.nextInt();

        for (int j = s2; j <=m ; j++)
            pw.println(s1 + " "+j);
        for (int j = s2 - 1 ; j >= 1 ; j--)
            pw.println(s1 + " "+j);

        boolean f = false;
        for (int i = s1 - 1 ; i >= 1 ; i--) {

            for (int j = f ? m : 1; (f ? j >= 1 : j <= m); ) {
                pw.println(i + " "+j);
                if(f)
                    j--;
                else
                    j++;
            }
            f=!f;
        }

        f = !f;
        for (int i = s1 + 1 ; i <= n ; i++) {

            for (int j = f ? m : 1; (f ? j >= 1 : j <= m); ) {
                pw.println(i + " "+j);
                if(f)
                    j--;
                else
                    j++;
            }
            f=!f;
        }

        pw.close();
    }
    static class Point implements Comparable<Point>
    {
        int x ,y ;

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

        @Override
        public int compareTo(Point o) {
            if (x == o.x) {
                return y - o.y;
            }
            return x - o.x;
        }

        @Override
        public String toString() {
            return "Point{" +
                    "x=" + x +
                    ", y=" + y +
                    '}';
        }
    }

    static class Circle implements Comparable<Circle>
    {
        int x , radius;
        public Circle(int x , int r)
        {
            this.x = x;
            this.radius = r;
        }

        public boolean isInside(Point p)
        {
            return Math.sqrt((p.x - x)*(p.x - x) + (p.y)*(p.y)) <= radius;
        }

        @Override
        public String toString() {
            return "Circle{" +
                    "x=" + x +
                    ", radius=" + radius +
                    '}';
        }

        @Override
        public int compareTo(Circle o) {
            return x - o.x;
        }
    }

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

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

    private  static int dis(int xa , int ya , int xb , int yb)
    {
        return (xa-xb)*(xa - xb) + (ya- yb)*(ya-yb);
    }

    static class Pair implements Comparable<Pair> {
        int x,y;

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

        public int compareTo(Pair o) {
            if (y  == o.y)
                return x - o.x;
            return y - o.y;

        }

        public double dis(Pair a){

            return (a.x - x)*(a.x - x) + (a.y-y)*(a.y-y);
        }

        public String toString() {
            return  x+" "+ y;
        }
        public boolean overlap(Pair a)
        {
            if((this.x >= a.x && this.x <= a.y) || (a.x >= this.x && a.x <= this.y)) return true;
            return false;

        }
    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

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

        public boolean check() {
            if (!st.hasMoreTokens())
                return false;
            return true;
        }

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

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

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

        public double nextDouble() {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if (x.charAt(0) == '-') {
                neg = true;
                start++;
            }
            for (int i = start; i < x.length(); i++)
                if (x.charAt(i) == '.') {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                } else {
                    sb.append(x.charAt(i));
                    if (dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg ? -1 : 1);
        }

        public boolean ready() {
            try {
                return br.ready();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}


import java.awt.*;
import java.io.*;

import java.math.BigInteger;
import java.util.*;

public class TaskC {

    static class Edge implements Comparable<Edge> {
        int v,cost;

        public Edge( int x, int y) {
            this.v = x;
            this.cost = y;
        }

        public int compareTo(Edge o) {
            if (cost  == o.cost)
                return v - o.v;
            return v - o.v;
        }

        @Override
        public boolean equals(Object o) {
            Edge edge = (Edge) o;
            return v == edge.v &&
                   cost == edge.cost;
        }

        public String toString() {
            return  v+" "+ cost;
        }
    }
    static long sum = 0;
    static ArrayList<Edge>[]adjList;
    static int reaches;
    static boolean[]vis;
    static HashSet<Integer> set;

    static char[][] grid;
    static int R, C;
    static int[] dx = new int[]{-1, 1, 0, 0};
    static int[] dy = new int[]{0, 0, -1, 1};
    static boolean[]visited;

    static boolean valid(int i, int j , int R1 , int C1)
    {
        return i != -1 && j != -1 && i != R1 && j != C1;
    }

    static Queue<Point> bfs(int n, int m , int s1 , int s2)
    {
        Queue<Point> q = new LinkedList<Point>();
        q.add(new Point(s1 , s2));
        boolean visited [][] = new boolean[n][m];

        Queue<Point> ans = new LinkedList<>();
        while(!q.isEmpty())
        {
            Point p = q.poll();
            ans.add(p);
            for (int i = 0 ; i < dx.length; i++)
            {
                int x = p.x + dx[i], y = p.y + dy[i];
                if(valid(x , y , n , m) && !visited[x][y])
                {
                    visited[x][y] = true;
                    q.add(new Point(x,y));

                }
            }

        }
        return ans;
    }

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

        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);

        int n = sc.nextInt();
        int m = sc.nextInt();
        int s1 = sc.nextInt() - 1 ;
        int s2 = sc.nextInt() - 1;

        Queue<Point> ans = bfs(n,m , s1,s2);
        while (!ans.isEmpty())
            pw.println((ans.peek().x+1) +" "+(ans.poll().y+1) );
        pw.close();
    }
    static class Point implements Comparable<Point>
    {
        int x ,y ;

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

        @Override
        public int compareTo(Point o) {
            if (x == o.x) {
                return y - o.y;
            }
            return x - o.x;
        }

        @Override
        public String toString() {
            return "Point{" +
                    "x=" + x +
                    ", y=" + y +
                    '}';
        }
    }

    static class Circle implements Comparable<Circle>
    {
        int x , radius;
        public Circle(int x , int r)
        {
            this.x = x;
            this.radius = r;
        }

        public boolean isInside(Point p)
        {
            return Math.sqrt((p.x - x)*(p.x - x) + (p.y)*(p.y)) <= radius;
        }

        @Override
        public String toString() {
            return "Circle{" +
                    "x=" + x +
                    ", radius=" + radius +
                    '}';
        }

        @Override
        public int compareTo(Circle o) {
            return x - o.x;
        }
    }

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

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

    private  static int dis(int xa , int ya , int xb , int yb)
    {
        return (xa-xb)*(xa - xb) + (ya- yb)*(ya-yb);
    }

    static class Pair implements Comparable<Pair> {
        int x,y;

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

        public int compareTo(Pair o) {
            if (y  == o.y)
                return x - o.x;
            return y - o.y;

        }

        public double dis(Pair a){

            return (a.x - x)*(a.x - x) + (a.y-y)*(a.y-y);
        }

        public String toString() {
            return  x+" "+ y;
        }
        public boolean overlap(Pair a)
        {
            if((this.x >= a.x && this.x <= a.y) || (a.x >= this.x && a.x <= this.y)) return true;
            return false;

        }
    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

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

        public boolean check() {
            if (!st.hasMoreTokens())
                return false;
            return true;
        }

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

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

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

        public double nextDouble() {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if (x.charAt(0) == '-') {
                neg = true;
                start++;
            }
            for (int i = start; i < x.length(); i++)
                if (x.charAt(i) == '.') {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                } else {
                    sb.append(x.charAt(i));
                    if (dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg ? -1 : 1);
        }

        public boolean ready() {
            try {
                return br.ready();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}


import java.awt.*;
import java.io.*;

import java.math.BigInteger;
import java.util.*;

public class TaskC {

    static class Edge implements Comparable<Edge> {
        int v,cost;

        public Edge( int x, int y) {
            this.v = x;
            this.cost = y;
        }

        public int compareTo(Edge o) {
            if (cost  == o.cost)
                return v - o.v;
            return v - o.v;
        }

        @Override
        public boolean equals(Object o) {
            Edge edge = (Edge) o;
            return v == edge.v &&
                    cost == edge.cost;
        }

        public String toString() {
            return  v+" "+ cost;
        }
    }
    static long sum = 0;
    static ArrayList<Edge>[]adjList;
    static int reaches;
    static boolean[]vis;
    static HashSet<Integer> set;

    static char[][] grid;
    static int R, C;
    static int[] dx = new int[]{-1, 1, 0, 0};
    static int[] dy = new int[]{0, 0, -1, 1};
    static boolean[]visited;

    static boolean valid(int i, int j , int R1 , int C1)
    {
        return i != -1 && j != -1 && i != R1 && j != C1;
    }

    static Queue<Point> bfs(int n, int m , int s1 , int s2)
    {
        Queue<Point> q = new LinkedList<Point>();
        q.add(new Point(s1 , s2));
        boolean visited [][] = new boolean[n][m];
        visited[s1][s2] = true;
        Queue<Point> ans = new LinkedList<>();
        while(!q.isEmpty())
        {
            Point p = q.poll();
            ans.add(p);
            for (int i = 0 ; i < dx.length; i++)
            {
                int x = p.x + dx[i], y = p.y + dy[i];
                if(valid(x , y , n , m) && !visited[x][y])
                {
                    visited[x][y] = true;
                    q.add(new Point(x,y));

                }
            }

        }
        return ans;
    }

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

        Scanner sc = new Scanner(System.in);
        PrintWriter pw = new PrintWriter(System.out);

        int n = sc.nextInt();
        int m = sc.nextInt();
        int s1 = sc.nextInt();
        int s2 = sc.nextInt();

        for (int j = s2; j <=m ; j++)
            pw.println(s1 + " "+j);
        for (int j = s2 - 1 ; j >= 1 ; j--)
            pw.println(s1 + " "+j);

        boolean f = false;
        for (int i = s1 - 1 ; i >= 1 ; i--) {

            for (int j = f ? m : 1; (f ? j >= 1 : j <= m); ) {
                pw.println(i + " "+j);
                if(f)
                    j--;
                else
                    j++;
            }
            f=!f;
        }
        //f = !f;
        for (int i = s1 + 1 ; i <= n ; i++) {

            for (int j = f ? m : 1; (f ? j >= 1 : j <= m); ) {
                pw.println(i + " "+j);
                if(f)
                    j--;
                else
                    j++;
            }
            f=!f;
        }

        pw.close();
    }
    static class Point implements Comparable<Point>
    {
        int x ,y ;

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

        @Override
        public int compareTo(Point o) {
            if (x == o.x) {
                return y - o.y;
            }
            return x - o.x;
        }

        @Override
        public String toString() {
            return "Point{" +
                    "x=" + x +
                    ", y=" + y +
                    '}';
        }
    }

    static class Circle implements Comparable<Circle>
    {
        int x , radius;
        public Circle(int x , int r)
        {
            this.x = x;
            this.radius = r;
        }

        public boolean isInside(Point p)
        {
            return Math.sqrt((p.x - x)*(p.x - x) + (p.y)*(p.y)) <= radius;
        }

        @Override
        public String toString() {
            return "Circle{" +
                    "x=" + x +
                    ", radius=" + radius +
                    '}';
        }

        @Override
        public int compareTo(Circle o) {
            return x - o.x;
        }
    }

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

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

    private  static int dis(int xa , int ya , int xb , int yb)
    {
        return (xa-xb)*(xa - xb) + (ya- yb)*(ya-yb);
    }

    static class Pair implements Comparable<Pair> {
        int x,y;

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

        public int compareTo(Pair o) {
            if (y  == o.y)
                return x - o.x;
            return y - o.y;

        }

        public double dis(Pair a){

            return (a.x - x)*(a.x - x) + (a.y-y)*(a.y-y);
        }

        public String toString() {
            return  x+" "+ y;
        }
        public boolean overlap(Pair a)
        {
            if((this.x >= a.x && this.x <= a.y) || (a.x >= this.x && a.x <= this.y)) return true;
            return false;

        }
    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(FileReader r) {
            br = new BufferedReader(r);
        }

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

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

        public boolean check() {
            if (!st.hasMoreTokens())
                return false;
            return true;
        }

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

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

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

        public double nextDouble() {
            String x = next();
            StringBuilder sb = new StringBuilder("0");
            double res = 0, f = 1;
            boolean dec = false, neg = false;
            int start = 0;
            if (x.charAt(0) == '-') {
                neg = true;
                start++;
            }
            for (int i = start; i < x.length(); i++)
                if (x.charAt(i) == '.') {
                    res = Long.parseLong(sb.toString());
                    sb = new StringBuilder("0");
                    dec = true;
                } else {
                    sb.append(x.charAt(i));
                    if (dec)
                        f *= 10;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg ? -1 : 1);
        }

        public boolean ready() {
            try {
                return br.ready();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }
}


import java.util.ArrayList;
import java.util.Arrays;
import javax.management.RuntimeErrorException;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Random;
import java.io.FileWriter;
import java.io.PrintWriter;
/*
    Solution Created: 18:52:51 12/08/2020
    Custom Competitive programming helper.
*/

public class Main {
	static boolean[][] visited;
	static ArrayList<Pair> ans = new ArrayList<Main.Pair>();
	static int cnt=0, n,m;
	public static void solve(Reader in, Writer out) {
		n = in.nextInt(); m = in.nextInt();
		int sx = in.nextInt(), sy = in.nextInt();
		visited = new boolean[n][m];
		ans.add(new Pair(sx,sy));
		for(int j = m-1; j>=0; j--) if(j+1!=sy) ans.add(new Pair(sx,j+1));
		for(int j = 0; j<m; j++) {
			if(j%2==0) {
				for(int i = 0; i<n; i++) {
					if(i+1!=sx) ans.add(new Pair(i+1, j+1));
				}
			}else {
				for(int i = n-1; i>=0; i--) {
					if(i+1!=sx) ans.add(new Pair(i+1, j+1));
				}
			}
		}

		for(Pair p : ans) out.println(p.x +" "+p.y);
	}
	static class Pair{
		int x, y;
		public Pair(int x, int y) {
			this.x = x;
			this.y = y;
		}
	}
	public static void main(String[] args) {
		Reader in = new Reader();
		Writer out = new Writer();
		solve(in, out);
		out.exit();
	}

static class Reader {
	static BufferedReader br;
	static StringTokenizer st;
	private int charIdx = 0;
	private String s;

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

	public Reader(String f){
		try {
			this.br = new BufferedReader(new FileReader(f));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

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

	public double[] nd(int n) {
		double[] a = new double[n];
		for (int i = 0; i < n; i++)
			a[i] = nextDouble();
		return a;
	}

	public char nextChar() {
		if (s == null || charIdx >= s.length()) {
			if (st == null || !st.hasMoreTokens())
				try {
					readLine();
				} catch (Exception e) {
				}
			s = st.nextToken();
			charIdx = 0;
		}
		return s.charAt(charIdx++);
	}

	public long[] nl(int n) {
		long[] a = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = nextLong();
		return a;
	}

	public char[] nca() {
		return next().toCharArray();
	}

	public String[] nS(int n) {
		String[] a = new String[n];
		for (int i = 0; i < n; i++)
			a[i] = next();
		return a;
	}

	public int nextInt() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Integer.parseInt(st.nextToken());
	}

	public double nextDouble() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Double.parseDouble(st.nextToken());
	}

	public Long nextLong() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return Long.parseLong(st.nextToken());
	}

	public String next() {
		if (st == null || !st.hasMoreTokens())
			try {
				readLine();
			} catch (Exception e) {
			}
		return st.nextToken();
	}

	public static void readLine() {
		try {
			st = new StringTokenizer(br.readLine());
		} catch (Exception e) {
		}
	}
}

static class Util{
		private static Random random = new Random();
		static long[] fact;
		public static void initFactorial(int n, long mod) {
			fact = new long[n+1];
			fact[0] = 1;
			for (int i = 1; i < n+1; i++) fact[i] = (fact[i - 1] * i) % mod;
		}
		public static long modInverse(long a, long MOD) {
			long[] gcdE = gcdExtended(a, MOD);
			if (gcdE[0] != 1) return -1; // Inverted doesn't exist
			long x = gcdE[1];
			return (x % MOD + MOD) % MOD;
		}
		public static long[] gcdExtended(long p, long q) {
			if (q == 0) return new long[] { p, 1, 0 };
			long[] vals = gcdExtended(q, p % q);
			long tmp = vals[2];
			vals[2] = vals[1] - (p / q) * vals[2];
			vals[1] = tmp;
			return vals;
		}
		public static long nCr(int n, int r, long MOD) {
			if (r == 0) return 1;
			return (fact[n] * modInverse(fact[r], MOD) % MOD * modInverse(fact[n - r], MOD) % MOD) % MOD;
		}
		public static long nCr(int n, int r) {
			return (fact[n]/fact[r])/fact[n-r];
		}
		public static long nPr(int n, int r, long MOD) {
			if (r == 0) return 1;
			return (fact[n] * modInverse(fact[n - r], MOD) % MOD) % MOD;
		}
		public static long nPr(int n, int r) {
			return fact[n]/fact[n-r];
		}
		public static boolean isPrime(int 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 * i <= n; i = i + 6)
	            if (n % i == 0 || n % (i + 2) == 0)
	            return false;
	        return true;
	    }
	    public static int lowerBound(int[] a, int v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(v<=a[mid]) h = mid;
	    		else l = mid+1;
	    	}
	    	return l;
	    }
	    public static int lowerBound(long[] a, long v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(v<=a[mid]) h = mid;
	    		else l = mid+1;
	    	}
	    	return l;
	    }
	    public static int upperBound(int[] a, int v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(a[mid]<=v) l = mid+1;
	    		else h = mid;
	    	}
	    	return l;
	    }
	    public static int upperBound(long[] a, long v) {
	    	int l = 0, h = a.length;
	    	while(l<h) {
	    		int mid = (l+h)/2;
	    		if(a[mid]<=v) l = mid+1;
	    		else h = mid;
	    	}
	    	return l;
	    }
	    public static boolean[] getSieve(int n) {
	        boolean[] isPrime = new boolean[n+1];
	        for (int i = 2; i <= n; i++) isPrime[i] = true;
	        for (int i = 2; i*i <= n; i++) if (isPrime[i])
	                for (int j = i; i*j <= n; j++) isPrime[i*j] = false;
	        return isPrime;
	    }
	    public static int gcd(int a, int b) {
	    	int tmp = 0;
	    	while(b != 0) {
	    		tmp = b;
	    		b = a%b;
	    		a = tmp;
	    	}
	    	return a;
	    }
	    public static long gcd(long a, long b) {
	    	long tmp = 0;
	    	while(b != 0) {
	    		tmp = b;
	    		b = a%b;
	    		a = tmp;
	    	}
	    	return a;
	    }
	    public static int random(int min, int max) {
	    	return random.nextInt(max-min+1)+min;
	    }
		public static void dbg(Object... o) {
			System.out.println(Arrays.deepToString(o));
		}
		public static void reverse(int[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				int tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(int[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(long[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				long tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(long[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(float[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				float tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(float[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(double[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				double tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(double[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void reverse(char[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				char tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static void reverse(char[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static <T> void reverse(T[] s, int l , int r) {
			for(int i = l; i<=(l+r)/2; i++) {
				T tmp = s[i];
				s[i] = s[r+l-i];
				s[r+l-i] = tmp;
			}
	    }
		public static <T> void reverse(T[] s) {
			reverse(s, 0, s.length-1);
	    }
		public static void shuffle(int[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            int t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(long[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            long t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(float[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            float t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(double[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            double t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static void shuffle(char[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            char t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
	    public static <T> void shuffle(T[] s) {
	        for (int i = 0; i < s.length; ++i) {
	            int j = random.nextInt(i + 1);
	            T t = s[i];
	            s[i] = s[j];
	            s[j] = t;
	        }
	    }
		public static void sortArray(int[] a) {
	        shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(long[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(float[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(double[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static void sortArray(char[] a) {
			shuffle(a);
	        Arrays.sort(a);
	    }
		public static <T extends Comparable<T>> void sortArray(T[] a) {
	        Arrays.sort(a);
	    }
	}

static class Writer {
	private PrintWriter pw;
	public Writer(){
		pw = new PrintWriter(System.out);
	}

	public Writer(String f){
		try {
			pw = new PrintWriter(new FileWriter(f));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public void printArray(int[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
	}
	public void printlnArray(int[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
		pw.println();
	}
	public void printArray(long[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
	}
	public void printlnArray(long[] a) {
		for(int i = 0; i<a.length; i++) print(a[i]+" ");
		pw.println();
	}
	public void print(Object o) {
		pw.print(o.toString());
	}
	public void println(Object o) {
		pw.println(o.toString());
	}
	public void println() {
		pw.println();
	}
	public void flush() {
		pw.flush();
	}
	public void exit() {
		pw.close();
	}
}
}