#include <bits/stdc++.h>
using namespace std;
int M, R, C, S, T, a[8], b[8], id[8];
vector<vector<vector<int> > > ver;
void createVer(int prod, int cur) {
  if (cur == M) return;
  for (int i = 1; i <= (int)(a[0]); ++i)
    for (int j = 1; j <= (int)(prod); ++j) {
      ver[i][j][cur] = 1;
    }
  for (int k = 2; k <= a[cur]; ++k) {
    for (int i = 1; i <= (int)(a[0]); ++i) {
      int tmp = ver[i].size();
      for (int j = tmp - 1; j >= tmp - prod; --j) ver[i].push_back(ver[i][j]);
    }
    for (int i = 1; i <= (int)(a[0]); ++i)
      for (int j = ver[1].size() - prod; j < ver[1].size(); ++j) {
        ver[i][j][cur] = k;
      }
  }
  createVer(prod * a[cur], cur + 1);
}
void print(int r1, int c1, int r2, int c2) {
  for (int k = 0; k < (int)(M); ++k)
    if (ver[r1][c1][k] != ver[r2][c2][k]) {
      if (ver[r1][c1][k] < ver[r2][c2][k])
        printf("inc %d\n", id[k] + 1);
      else
        printf("dec %d\n", id[k] + 1);
    }
}
void rightRotate(int& s, int& t) {
  vector<vector<vector<int> > > new_ver(
      C + 1, vector<vector<int> >(R + 1, vector<int>(M)));
  for (int i = 1; i <= (int)(R); ++i)
    for (int j = 1; j <= (int)(C); ++j) {
      new_ver[j][R - i + 1] = ver[i][j];
    }
  swap(s, t);
  t = R - t + 1;
  swap(R, C);
  ver = new_ver;
}
void solve_corner(int s, int t) {
  int dx, dy;
  dx = s == 1 ? 1 : -1;
  for (;; s += dx) {
    dy = t == 1 ? 1 : -1;
    for (;; t += dy) {
      if (t + dy > C || t + dy < 1) break;
      print(s, t, s, t + dy);
    }
    if (s + dx > R || s + dx < 1) break;
    print(s, t, s + dx, t);
  }
}
void solve_border(int s, int t) {
  while (t != 1) rightRotate(s, t);
  S = s, T = t;
  int dx, dy;
  dx = -1;
  for (;; s += dx) {
    dy = t == 1 ? 1 : -1;
    for (;; t += dy) {
      if (t + dy >= C || t + dy < 1) break;
      print(s, t, s, t + dy);
    }
    if (s + dx < 1) break;
    print(s, t, s + dx, t);
  }
  print(s, t, s, t + 1);
  t++;
  while (s <= S) print(s, t, s + 1, t), s++;
  dx = 1;
  for (;; s += dx) {
    dy = t == 1 ? 1 : -1;
    for (;; t += dy) {
      if (t + dy > C || t + dy < 1) break;
      print(s, t, s, t + dy);
    }
    if (s + dx > R) break;
    print(s, t, s + dx, t);
  }
}
void solve_odd(int s, int t) {
  S = s, T = t;
  int dx, dy;
  while (s < R) print(s, t, s + 1, t), s++;
  print(s, t, s, t - 1);
  t--;
  dx = -1;
  for (;; s += dx) {
    dy = t == 1 ? 1 : -1;
    for (;; t += dy) {
      if (t + dy >= T || t + dy < 1) break;
      print(s, t, s, t + dy);
    }
    if (s + dx < S) break;
    print(s, t, s + dx, t);
  }
  print(s, t, s - 1, t);
  s--;
  dy = 1;
  for (;; t += dy) {
    dx = s == 1 ? 1 : -1;
    for (;; s += dx) {
      if (s + dx >= S || s + dx < 1) break;
      print(s, t, s + dx, t);
    }
    if (t + dy > T) break;
    print(s, t, s, t + dy);
  }
  print(s, t, s, t + 1);
  t++;
  for (;; t += dy) {
    dx = s == 1 ? 1 : -1;
    for (;; s += dx) {
      if (s + dx > R || s + dx < 1) break;
      print(s, t, s + dx, t);
    }
    if (t + dy > C) break;
    print(s, t, s, t + dy);
  }
}
void solve_even(int s, int t) {
  S = s, T = t;
  int dx, dy;
  dy = -1;
  for (;; t += dy) {
    dx = s == R ? -1 : 1;
    for (;; s += dx) {
      if (s + dx < S || s + dx > R) break;
      print(s, t, s + dx, t);
    }
    if (t + dy < 1) break;
    print(s, t, s, t + dy);
  }
  while (s > 1) print(s, t, s - 1, t), s--;
  print(s, t, s, t + 1), t++;
  dx = 1;
  for (;; s += dx) {
    dy = t == 2 ? 1 : -1;
    for (;; t += dy) {
      if (t + dy > T + 1 || t + dy < 2) break;
      print(s, t, s, t + dy);
    }
    if (s + dx == S) break;
    print(s, t, s + dx, t);
  }
  while (s < R) print(s, t, s + 1, t), s++;
  if (t == C) return;
  print(s, t, s, t + 1), t++;
  dy = 1;
  for (;; t += dy) {
    dx = s == 1 ? 1 : -1;
    for (;; s += dx) {
      if (s + dx < 1 || s + dx > R) break;
      print(s, t, s + dx, t);
    }
    if (t + dy > C) break;
    print(s, t, s, t + dy);
  }
}
void solve_path(int s, int t) {
  printf("Path\n");
  if ((s == 1 || s == R) && (t == 1) || (t == C))
    solve_corner(s, t);
  else if (s == 1 || s == R || t == 1 || t == C)
    solve_border(s, t);
  else if (s & 1)
    solve_odd(s, t);
  else
    solve_even(s, t);
}
void solve_cycle(int s, int t) {
  printf("Cycle\n");
  while (C & 1 || s == 1) rightRotate(s, t);
  S = s, T = t;
  int dx, dy;
  if (T == 1) goto NEXT;
  if (T & 1) print(s, t, s, t - 1), t--;
  dy = -1;
  for (;; t += dy) {
    dx = s == R ? -1 : 1;
    for (;; s += dx) {
      if (s + dx > R || s + dx < S) break;
      print(s, t, s + dx, t);
    }
    if (t + dy < 1) break;
    print(s, t, s, t + dy);
  }
NEXT:
  print(s, t, s - 1, t);
  s--;
  dy = 1;
  for (;; t += dy) {
    dx = s == 1 ? 1 : -1;
    for (;; s += dx) {
      if (s + dx >= S || s + dx < 1) break;
      print(s, t, s + dx, t);
    }
    if (t + dy > C) break;
    print(s, t, s, t + dy);
  }
  print(s, t, s + 1, t), s++;
  dy = -1;
  for (;; t += dy) {
    if (t == T && (T & 1) == 0) break;
    dx = s == R ? -1 : 1;
    for (;; s += dx) {
      if (s + dx > R || s + dx < S) break;
      print(s, t, s + dx, t);
    }
    if (t + dy < T) break;
    print(s, t, s, t + dy);
  }
}
int main() {
  scanf("%d", &M);
  for (int i = 0; i < (int)(M); ++i) scanf("%d", &a[i]);
  for (int i = 0; i < (int)(M); ++i) scanf("%d", &b[i]);
  if (M == 1) {
    if (a[0] == 2) {
      printf("Cycle\n");
      printf("%s", b[0] == 1 ? "inc 1\ndec 1\n" : "dec 1\ninc 1\n");
    } else if (b[0] == 1 || b[0] == a[0]) {
      printf("Path\n");
      for (int i = 0; i < (int)(a[0] - 1); ++i)
        printf("%s", b[0] == 1 ? "inc 1\n" : "dec 1\n");
    } else {
      printf("No\n");
    }
    return 0;
  }
  for (int i = 0; i < (int)(M); ++i) id[i] = i;
  for (int i = 0; i < (int)(M); ++i)
    if ((a[i] & 1) == 0) {
      swap(a[i], a[0]), swap(b[i], b[0]);
      swap(id[i], id[0]);
      break;
    }
  ver.resize(a[0] + 1, vector<vector<int> >(a[1] + 1, vector<int>(M, 0)));
  for (int i = 1; i <= (int)(a[0]); ++i)
    for (int j = 1; j <= (int)(a[1]); ++j) {
      ver[i][j][0] = i, ver[i][j][1] = j;
    }
  createVer(a[1], 2);
  R = a[0], C = ver[1].size() - 1;
  int s, t;
  for (int i = 1; i <= (int)(R); ++i)
    for (int j = 1; j <= (int)(C); ++j) {
      bool ok = true;
      for (int k = 0; k < (int)(M); ++k)
        if (ver[i][j][k] != b[k]) {
          ok = false;
          break;
        }
      if (ok) {
        s = i, t = j;
        break;
      }
    }
  if (R & 1 && C & 1 && (s + t) & 1) {
    printf("No\n");
    return 0;
  }
  if (R & 1 && C & 1)
    solve_path(s, t);
  else
    solve_cycle(s, t);
  return 0;
}
