import std.conv, std.functional, std.stdio, std.string;
import std.algorithm, std.array, std.bigint, std.container, std.math, std.numeric, std.range, std.regex, std.typecons;
import core.bitop;

class EOFException : Throwable { this() { super("EOF"); } }
string[] tokens;
string readToken() { for (; tokens.empty; ) { if (stdin.eof) { throw new EOFException; } tokens = readln.split; } auto token = tokens.front; tokens.popFront; return token; }
int readInt() { return readToken.to!int; }
long readLong() { return readToken.to!long; }
real readReal() { return readToken.to!real; }

bool chmin(T)(ref T t, in T f) { if (t > f) { t = f; return true; } else { return false; } }
bool chmax(T)(ref T t, in T f) { if (t < f) { t = f; return true; } else { return false; } }

int binarySearch(alias pred, T)(in T[] as) { int lo = -1, hi = cast(int)(as.length); for (; lo + 1 < hi; ) { const mid = (lo + hi) >> 1; (unaryFun!pred(as[mid]) ? hi : lo) = mid; } return hi; }
int lowerBound(T)(in T[] as, T val) { return as.binarySearch!(a => (a >= val)); }
int upperBound(T)(in T[] as, T val) { return as.binarySearch!(a => (a > val)); }


// a b (mod m)
ulong multiply(ulong a, ulong b, ulong m)
in {
  assert(m < 1UL << 63, "multiply: m < 2^63 must hold");
  assert(a < m, "multiply: a < m must hold");
  assert(b < m, "multiply: b < m must hold");
}
do {
  ulong c = 0;
  for (; a; a >>= 1) {
    if (a & 1) {
      c += b;
      if (c >= m) c -= m;
    }
    b <<= 1;
    if (b >= m) b -= m;
  }
  return c;
}


long P, B;

void main() {
  try {
    for (; ; ) {
      P = readLong();
      B = readLong();
      
      for (int n = 1; n <= 1 << 16; n <<= 1) {
        auto BB = new long[n];
        BB[0] = 1;
        foreach (i; 1 .. n) {
          BB[i] = multiply(BB[i - 1], B, P);
        }
        debug {
          writeln("n = ", n);
          writeln("  BB = ", BB);
        }
        int k = n;
        auto l = new int[2 * n];
        auto r = new int[2 * n];
        l[] = -1;
        r[] = -1;
        auto crt = new Tuple!(long, int)[n];
        foreach (i; 0 .. n) {
          crt[i] = tuple(BB[i], i);
        }
        for (; crt.length > 1; ) {
          crt.sort;
          debug {
            writeln("  crt = ", crt);
          }
          Tuple!(long, int)[] nxt;
          for (int j = 0; j < crt.length; j += 2) {
            nxt ~= tuple(crt[j + 1][0] - crt[j + 0][0], k);
            l[k] = crt[j + 0][1];
            r[k] = crt[j + 1][1];
            ++k;
            if (nxt[$ - 1][0] == 0) {
              auto sigs = new int[n];
              void dfs(int u, int s) {
                if (u < n) {
                  sigs[u] = s;
                } else {
                  dfs(l[u], -s);
                  dfs(r[u], +s);
                }
              }
              dfs(k - 1, +1);
              auto ansS = new char[n];
              auto ansT = new char[n];
              foreach (i; 0 .. n) {
                switch (sigs[i]) {
                  case -1: ansS[i] = 'a'; ansT[i] = 'b'; break;
                  case  0: ansS[i] = 'a'; ansT[i] = 'a'; break;
                  case +1: ansS[i] = 'b'; ansT[i] = 'a'; break;
                  default: assert(false);
                }
              }
              ansS.reverse;
              ansT.reverse;
              writeln(ansS.to!string);
              writeln(ansT.to!string);
              goto found;
            }
          }
          crt = nxt;
        }
      }
     found:;
    }
  } catch (EOFException e) {
  }
}