import math

def getDataDependenceSum(n):
    m = int(math.isqrt(n))
    maxSmallX = n // m
    sumSmallX = (maxSmallX * (maxSmallX + 1)) // 2
    myst1c = sumSmallX
    for k in range(1, m + 1):
        x = n // k
        if x > maxSmallX:
            myst1c += x
    return myst1c

import java.util.TreeSet;
public class Main {
    public int TaichiAndLand(int n, int m, int[][] arr, int K) {
        int maxSum = Integer.MIN_VALUE;
        for (int top = 0; top < n; top++) {
            int[] columnSum = new int[m];
            for (int bottom = top; bottom < n; bottom++) {
                for (int col = 0; col < m; col++) {
                    columnSum[col] += arr[bottom][col];
                }
                maxSum = Math.max(maxSum, solve(columnSum, K));
            }
        }

        return maxSum;
    }
    private int solve(int[] nums, int K) {
        int sum = 0;
        int maxSum = Integer.MIN_VALUE;
        TreeSet<Integer> cc = new TreeSet<>();
        cc.add(0);

        for (int num : nums) {
            sum += num;
            Integer prefix = cc.ceiling(sum - K);
            if (prefix != null) {
                maxSum = Math.max(maxSum, sum - prefix);
            }

            cc.add(sum);
        }

        return maxSum;
    }

import java.util.*;
public class Main {
    static class DSU {
        int[] parent, size;
        public DSU(int n) {
            parent = new int[n];
            size = new int[n];
            for (int i = 0; i < n; i++) {
                parent[i] = i;
                size[i] = 1;   
            }
        }
        public int find(int x) {
            if (parent[x] != x) {
                parent[x] = find(parent[x]); 
            }
            return parent[x];
        }
        public void union(int x, int y) {
            int rootX = find(x);
            int rootY = find(y);
            if (rootX != rootY) {
                if (size[rootX] < size[rootY]) {
                    parent[rootX] = rootY;
                    size[rootY] += size[rootX];
                } else {
                    parent[rootY] = rootX;
                    size[rootX] += size[rootY];
                }
            }
        }
    }
    public static int solution(int n, int p, int[][] programmers) {
        DSU dsu = new DSU(n);
                for (int i = 0; i < p; i++) {
            int u = programmers[i][0];
            int v = programmers[i][1];
            dsu.union(u, v);
        }
        Map<Integer, Integer> componentSize = new HashMap<>();
        for (int i = 0; i < n; i++) {
            int root = dsu.find(i);
            componentSize.put(root, componentSize.getOrDefault(root, 0) + 1);
        }
        long totalPairs = (long) n * (n - 1) / 2;
                for (int size : componentSize.values()) {
            totalPairs -= (long) size * (size - 1) / 2;
        }

        return (int) totalPairs;
    }

import java.util.Scanner;
public class ColorChange {
    private static void solve(int[][] image, int row, int col, int newColor, int originalColor) {
        if (row < 0 || row >= image.length || col < 0 || col >= image[0].length) {
            return; 
        }
        if (image[row][col] != originalColor) {
            return; 
        }
         image[row][col] = newColor;
        solve(image, row + 1, col, newColor, originalColor); 
        solve(image, row - 1, col, newColor, originalColor); 
        solve(image, row, col + 1, newColor, originalColor); 
        solve(image, row, col - 1, newColor, originalColor); 
    }
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int rows = scanner.nextInt();
        int cols = scanner.nextInt();
        int[][] image = new int[rows][cols];
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                image[i][j] = scanner.nextInt();
            }
        }
        int sourceRow = scanner.nextInt();
        int sourceCol = scanner.nextInt();
        int newColor = scanner.nextInt();
        int originalColor = image[sourceRow][sourceCol];
        if (originalColor != newColor) { 
            solve(image, sourceRow, sourceCol, newColor, originalColor);
        }
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < cols; j++) {
                System.out.print(image[i][j] + " ");
            }
            System.out.println();
        }

        scanner.close();
    }
}

#include<bits/stdc++.h>
using namespace std;
using ll = Long Long;

int mod = 1e9 + 7;
int dp[1000001][2][2][2];

int F(int i, int reqdParity, int currparity, int ended, vector<int> &A) {
    if (i < 0) return ended;

    if (dp[i][reqdParity][currparity][ended] != -1) 
        return dp[i][reqdParity][currparity][ended];

    int newParity = (currparity + A[i]) % 2;

    ll Continue = F(i - 1, reqdParity, newParity, 0, A);
    ll EndHere = reqdParity == newParity ? F(i - 1, 1 - newParity, 0, 1, A) : 0;

    return dp[i][reqdParity][currparity][ended] = (Continue + EndHere) % mod;
}

int findNumberOfPartitions(int N, vector<int> A) {
    memset(dp, -1, sizeof(dp));
    return (F(N - 1, 0, 0, 0, A) + F(N - 1, 1, 0, 1, A)) % mod;
}

#include <iostream>
#include <vector>
#include <algorithm>
using ll = long long;
using namespace std;
int getMinimumUniqueSum(vector<int> &arr) {
    sort(arr.begin(), arr.end());
    ll sum = arr[0];  
    for (int i = 1; i < arr.size(); i++) {
        if (arr[i] <= arr[i - 1]) {
            arr[i] = arr[i - 1] + 1;
        }
        sum += arr[i];
    }
    
    return sum;
}