/*Look at Abhinav man, so inspirational*/
#pragma GCC optimize ("-O3")
#include<bits/stdc++.h>
typedef long long ll;
using namespace std;
#define forn(i,x,n) for(ll i=x;i<n;i++)
#define pb push_back
#define int             long long
#define mp make_pair
#define debug(x) cout<<x<<"\n";
#define lb lower_bound
#define ub upper_bound
#define bs binary_search
#define mod 1000000007
#define endl '\n'
 
int n,m,k,a,b,c,d,x,y,z,q,e,v;
string s;
int ans;
int arr[1000000];
int brr[1000000];
int crr[1000000];
char vec[100000];
int nCr(int n, int r)
{
 
	int p = 1, k = 1;
 
	// C(n, r) == C(n, n-r),
	// choosing the smaller value
	if (n - r < r)
		r = n - r;
 
	if (r != 0) {
		while (r) {
			p *= n;
			k *= r;
 
			// gcd of p, k
			int m = __gcd(p, k);
 
			// dividing by gcd, to simplify
			// product division by their gcd
			// saves from the overflow
			p /= m;
			k /= m;
 
			n--;
			r--;
		}
 
		// k should be simplified to 1
		// as C(n, r) is a natural number
		// (denominator should be 1 ) .
	}
 
	else
		p = 1;
 
	// if our approach is correct p = ans and k =1
	return p;
}

int32_t main()
{
     ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
   //std::cout << fixed<< std::setprecision(9) << '\n';
  
   int  t;
    t=1;
    //cin>>t;
    while(t--)
    {  
	cin >> a >> b >> k;
	int n=a+b;
	for(int i=0;i<n;i++)
	{
		 if(a==0)
		 {
		 	 cout<<'b';
		 	 b--;
		 	 continue;
		 }
		else if(b==0)
		 {
		 	 cout<<'a';
		 	 a--;
		 	 continue;
		 }
		   d=nCr(a+b-1,a-1);
		   if(d<k)
		   {
		   	k-=d;
		   	cout<<'b';
		   	b--;
		   	
		   }
		   else
		   {
		   	cout<<'a';
		   	a--;
		   }
		
		 
	}

	   
	  
}
} 


#include<bits/stdc++.h>
using namespace std;
const int toSreachDirX[4]={-1,0,1,0};
const int toSreachDirY[4]={0,1,0,-1};
const string toSreachDir="URDL";
int Term=0;
const int Height=30;
const int Width=30;
unordered_map<char,int>Direction2Index={{'U',0},{'R',1},{'D',2},{'L',3}};
struct road{
  array<pair<int,int>,4>dist;
  road(){
    dist[0]={5000,0};
    dist[1]={5000,0};
    dist[2]={5000,0};
    dist[3]={5000,0};
  }
  pair<int,int>get(char s){
    switch (s){
      case 'U':
      return dist[0];
      case 'R':
      return dist[1];
      case 'D':
      return dist[2];
      case 'L':
      return dist[3];
      default:
      return pair<int,int>({1e8,0});
    }
  }
};
string solve(vector<vector<road>> &mati,int sx,int sy,int gx,int gy){
  string operate="";
  vector<vector<int>>dist(30,vector<int>(30,1e9));
  vector<vector<char>>op(30,vector<char>(30,'/'));
  dist[sx][sy]=0;
  priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>>dijk;
  dijk.push({0,sx*30+sy});
  while(dijk.size()){
    auto [d,vn]=dijk.top();
    dijk.pop();
    int vx=vn/30,vy=vn%30;
    if(d>dist[vx][vy])continue;
    for(int i=0;i<4;i++){
      if(vx+toSreachDirX[i]>=0 && vx+toSreachDirX[i]<30 && vy+toSreachDirY[i]>=0 && vy+toSreachDirY[i]<30){
        if(dist[vx+toSreachDirX[i]][vy+toSreachDirY[i]]>d+mati[vx][vy].get(toSreachDir[i]).first){
          dist[vx+toSreachDirX[i]][vy+toSreachDirY[i]]=d+mati[vx][vy].get(toSreachDir[i]).first;
          dijk.push({dist[vx+toSreachDirX[i]][vy+toSreachDirY[i]],(vx+toSreachDirX[i])*30+vy+toSreachDirY[i]});
          op[vx+toSreachDirX[i]][vy+toSreachDirY[i]]=toSreachDir[i];
        }
      }
    }
  }
  while(gx!=sx||gy!=sy){
    operate+=op[gx][gy];
    switch(op[gx][gy]){
      case 'U':
      gx++;break;
      case 'D':
      gx--;break;
      case 'R':
      gy--;break;
      case 'L':
      gy++;break;
    }
  }
  reverse(operate.begin(),operate.end());
  return operate;
}
string solve2(vector<vector<road>> &mati,int sx,int sy,int gx,int gy){
  string ret="";
  for(int i=0;i<sx-gx;i++){
    ret+='U';
  }
  for(int i=0;i<gx-sx;i++){
    ret+='D';
  }
  for(int i=0;i<sy-gy;i++){
    ret+='L';
  }
  for(int i=0;i<gy-sy;i++){
    ret+='R';
  }
  return ret;
}
void evoluate(vector<vector<road>> &mati,double dist,string &op,int sx,int sy){
  int len=op.size();
  for(int i=0;i<len;i++){
    auto t=mati[sx][sy].dist[Direction2Index[op[i]]];
    mati[sx][sy].dist[Direction2Index[op[i]]].first=(t.first*t.second+dist/len*2)/(t.second+2);
    mati[sx][sy].dist[Direction2Index[op[i]]].second++;
    sx+=toSreachDirX[Direction2Index[op[i]]];
    sy+=toSreachDirY[Direction2Index[op[i]]];
  }
}
int main(){
  vector<vector<road>> mati(30,vector<road>(30));
  double dist=0;
  int sx,sy,gx,gy;
  for(int i=0;i<1000;i++){
    Term++;
    cin>>sx>>sy>>gx>>gy;
    string t="";
    if(Term<250)t=solve2(mati,sx,sy,gx,gy);
    else t=solve(mati,sx,sy,gx,gy);
    cout<<t<<endl;
    cin>>dist;
    evoluate(mati,dist,t,sx,sy);
  }
  return 0;
}