#include <string>
#include <vector>
#include <deque>
#include <list>
#include <algorithm>
#include <map>
#include <set>
#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;

class Node {
  public:
    int T;
    int P;
    int back_class;
    Node *back_node;
    int path_length;
};

class CsCourses {
  public:
    vector <int> getOrder(vector <int> theoreticalValue, vector <int> practicalValue, vector <int> expire, int skillBound);
};

vector <int> CsCourses::getOrder(vector <int> TV, vector <int> PV, vector <int> E, int SB)
{
  int i, j;
  Node *n, *m;
  vector < vector <Node *> >N;
  deque <Node *> Q;
  vector <int> rv;

  N.resize(51);
  for (i = 0; i < 51; i++) {
    N[i].resize(51);
    for (j = 0; j < 51; j++) {
      N[i][j] = new Node;
      N[i][j]->T = i;
      N[i][j]->P = j;
      N[i][j]->back_node = NULL;
      N[i][j]->path_length = -1;
    }
  }

  n = N[0][0];
  n->path_length = 0;

  Q.push_back(n);

  while (!Q.empty()) {
    n = Q[0];
    Q.pop_front();
    if (n->T >= SB && n->P >= SB) {
      rv.resize(n->path_length);
      for (i = n->path_length-1; i >= 0; i--) {
        rv[i] = n->back_class;
        n = n->back_node;
      }
      return rv;
    }
    for (i = 0; i < TV.size(); i++) {
      if (TV[i] == n->T+1 || PV[i] == n->P+1) {
        if (TV[i] <= n->T+1 && PV[i] <= n->P+1 && E[i] > n->path_length) {
          m = N[(TV[i] < n->T) ? n->T : TV[i]][(PV[i] < n->P) ? n->P : PV[i]];
          if (m->path_length == -1) {
            m->path_length = n->path_length + 1;
            m->back_node = n;
            m->back_class = i;
            Q.push_back(m);
          }
        }
      }
    }
  }
  return rv;
}