import java.util.*;

public class zamboni_font
{
   public static void main(String[] args)
   {
      new zamboni_font(new Scanner(System.in));
   }

   // For a given step size and modulus, find all the positions in order for
   // each of the types of modulus. Runs in O(modulus).
   ArrayList<Integer> findCycles(int startStep, int modulus)
   {
      ArrayList<Integer> res = new ArrayList<Integer>();
      boolean[] seen = new boolean[modulus];
      int pos = startStep;
      while (!seen[pos])
      {
         seen[pos] = true;
         res.add(pos);
         pos = (pos+4)%modulus;
      }
      return res;
   }

   char getColor(int ord)
   {
      return (char)('A'+ord);
   }

   public zamboni_font(Scanner in)
   {
      int R = in.nextInt();
      int C = in.nextInt();
      int startRow = R-in.nextInt();
      int startCol = in.nextInt()-1;
      long numSteps = in.nextLong();
      char[][] grid = new char[R][C];
      for (int r=0; r<R; r++)
         Arrays.fill(grid[r], '.');
      
      // 0-up, 1-right, 2-down, 3-left
      // Determine the direction of the final move.
      int finalDir = (int)((numSteps+3)%4);

      // Determine the final color, in the range [0, 25]
      int finalColor = (int)((numSteps+25)%26);

      // Find the row where the zamboni ends. Think of all the operations that
      // only affect the 1D case of up and down. If the first move is indexed by 
      // 0, then these events happen on even numbered moves. We can find out
      // the number of up events of length K, and the number of down events
      // of length K. Since the room wraps, the length events are all 
      // mod numRows. We form an equivalence class of each of the event types 
      // and sum how many of each type of event occured. We have to do the same
      // for each dimension. So use the same code for columns and horizontal.
      long numVert = (numSteps+1)/2; // Gives the number of vertical events
      long numHori = numSteps-numVert; // Gives the number of horizontal events

      // Events are of length 1, 3, 5, 7, ... then cycle mod numRows
      // Up events go 1, 5, 9, 13, ... (+4 increments starting at 1)
      // Down events go 3, 7, 11, ... (+4 increments starting at 3)
      // Here is where we can apply the pidgeonhole principle. At some point
      // each of these lengths must cycle. That cycling must occur after
      // at most numRows steps. The type of cycling and length has a closed
      // form for each value of r in the congruence class (r = x (mod 4)).
      // Being a lazy computer scientist and not a lazy mathematician, I will
      // simply sim the steps and save the cycle lengths in the order found.
      // The code in my 1DSolver will handle this by picking a start location
      // and the number of steps in that direction. I will then reuse this
      // code to solve the horizontal piece of the problem.
      Solver1D vertical = new Solver1D(R, startRow, 1, numVert);
      Solver1D horizontal = new Solver1D(C, startCol, 2, numHori);
   
      // Sim painting the grid until all lines we paint are stripes
      int cap = Math.max(R, C);
      int firstSteps = (int)Math.min(cap, numSteps);
      int curDir = 0, curColor = 0;
      int[] dr = {1, 0, -1, 0};
      int[] dc = {0, 1, 0, -1};
      int curRow = startRow, curCol = startCol;
      for (int ss=1; ss<=firstSteps; ss++)
      {
         for (int i=0; i<ss; i++)
         {
            grid[curRow][curCol] = getColor(curColor);
            curRow += R+dr[curDir];
            curCol += C+dc[curDir];
            curRow %= R;
            curCol %= C;
         }
         curColor = (curColor+1) % 26;
         curDir = (curDir+1) % 4;
      }

      // *** BEGIN PAINT STRIPES ***
      // Next we need to paint the stripes. For the next part we must make some
      // observations. We cycle in each dimension in at most D steps where D
      // is the dimensionality of that dimension. This means that we will
      // observe / paint that row in at most D steps. We also know that the
      // same must hold for columns. This is by the pidgeonhole principle.
      // Therefore we only need to simulate the last R+C steps to get the
      // last time that color was painted.
      long[] timeColColored = new long[C];
      char[] colColor = new char[C];
      Arrays.fill(colColor, ' ');
      Arrays.fill(timeColColored, -1);
      long[] timeRowColored = new long[R];
      char[] rowColor = new char[R];
      Arrays.fill(timeRowColored, -1);
      Arrays.fill(rowColor, ' ');
      curDir = finalDir;
      curColor = finalColor;
      curRow = vertical.finalRow;
      curCol = horizontal.finalRow;
      for (int u=1; u<=5*(R+C)+1; u++)
      {
         if (numSteps-u < firstSteps) break;
         
         if (curDir % 2 == 0) // Paint a column
         {
            if (timeColColored[curCol] == -1)
            {
               timeColColored[curCol] = numSteps-u;
               colColor[curCol] = getColor(curColor);
            }
         }
         else // Paint a row
         {
            if (timeRowColored[curRow] == -1)
            {
               timeRowColored[curRow] = numSteps-u;
               rowColor[curRow] = getColor(curColor);
            }
         }

         // Rewind! Find the previous position before this one!
         long len = numSteps-u+1;
         curRow += (int)(R-((dr[curDir]*(len%R))%R));
         curCol += (int)(C-((dc[curDir]*(len%C))%C));
         curRow %= R;
         curCol %= C;

         curDir = (curDir+3)%4;
         curColor = (curColor+25)%26;
      }

      // Loop over all the cells and place the top-most color.
      for (int r=0; r<R; r++)
      {
         for (int c=0; c<C; c++)
         {
            if (timeRowColored[r] > timeColColored[c])
               grid[r][c] = rowColor[r];
            else if (timeRowColored[r] < timeColColored[c])
               grid[r][c] = colColor[c];
         }
      }
      // *** END PAINT STRIPES ***

      // Place the Zamboni at the ending location.
      grid[vertical.finalRow][horizontal.finalRow] = '@';

      // Print the answer
      for (int r=R-1; r>=0; r--)
         System.out.println(new String(grid[r]));
   }

   // Class to solve the 1D version of this problem.
   // This class cuts the work in half. You solve vertical and horizontal both
   // by using this class and changing the parameters. The class is coded
   // from the perspective of being vertical.
   class Solver1D
   {
      int N, finalRow;
      long numUp, numDown;
      long[] upCounter, downCounter;
      ArrayList<Integer> upEvents, downEvents;
      public Solver1D(int NN, int startLoc, int startLen, long numSteps)
      {
         N = NN;
         numUp = (numSteps+1)/2; // Gives the number of up events.
         numDown = numSteps-numUp; // Gives the number of down events.
         upEvents = findCycles(startLen%N, N);
         downEvents = findCycles((startLen+2)%N, N);
         upCounter = determineCounts(upEvents, numUp);
         downCounter = determineCounts(downEvents, numDown);
         
         finalRow = startLoc;
         for (int s=0; s<N; s++)
         {
            finalRow += (upCounter[s]%N)*s;
            finalRow += (N-downCounter[s]%N)*s;
            finalRow %= N;
         }
      }

      long[] determineCounts(ArrayList<Integer> events, long numSteps)
      {
         long[] res = new long[N];
         if (events.size() == 0) return res;
         long numFull = numSteps / events.size();
         for (int v : events)
            res[v] += numFull;
         int steps = (int)(numSteps % events.size());
         for (int i=0; i<steps; i++)
            res[events.get(i)] += 1;
         return res;
      }
   }
}