#include "longesttrip.h"

#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


// bool are_connected(std::vector<int> A, std::vector<int> B);

int N;
bool A[256][256];
void askAll() {
  memset(A, 0, sizeof(A));
  for (int u = 0; u < N; ++u) for (int v = u + 1; v < N; ++v) {
    A[u][v] = A[v][u] = are_connected({u}, {v});
  }
}

vector<int> vis;
vector<int> par;
vector<int> us;
void dfs(int u) {
  vis[u] = 1;
  us.push_back(u);
  for (int v = 0; v < N; ++v) if (A[u][v]) {
    if (!vis[v]) {
      par[v] = u;
      dfs(v);
    }
  }
}

std::vector<int> longest_trip(int N_, int D)
{
  N = N_;
  askAll();
  
  vis.assign(N, 0);
  par.assign(N, -1);
  us.clear();
  dfs(0);
  const int sz0 = us.size();
  if (sz0 < N) {
    if (sz0 >= N - sz0) {
      return us;
    }
    for (int u = 0; u < N; ++u) if (!vis[u]) {
      us.clear();
      dfs(u);
      assert((int)us.size() == N - sz0);
      return us;
    }
    assert(false);
  } else {
    for (; ; ) {
      vector<int> indeg(N, 0);
      for (int u = 0; u < N; ++u) if (~par[u]) {
        ++indeg[par[u]];
      }
      vector<int> ls;
      for (int u = 0; u < N; ++u) if (indeg[u] == 0) {
        ls.push_back(u);
      }
      const int lsLen = ls.size();
// cerr<<"par = "<<par<<", ls = "<<ls<<endl;
      bool yet = false;
      int j0 = -1, j1 = -1;
      for (j0 = 0; j0 < lsLen && j0 < 3; ++j0) for (j1 = j0 + 1; j1 < lsLen && j1 < 3; ++j1) {
        if (A[ls[j0]][ls[j1]]) {
          yet = true;
          goto found;
        }
      }
     found:{}
      if (yet) {
        vector<int> path;
        for (int u = ls[j1]; indeg[u] <= 1; u = par[u]) {
          path.push_back(u);
        }
        int p = ls[j0];
        for (const int u : path) {
          par[u] = p;
          p = u;
        }
      } else {
        assert(lsLen == 1 || lsLen == 2);
        if (lsLen == 1) {
          j0 = -1;
          j1 = 0;
        } else {
          for (j0 = 0; j0 < lsLen; ++j0) {
            if (A[0][ls[j0]]) {
              break;
            }
          }
          assert(j0 < lsLen);
          j1 = j0 ^ 1;
        }
        vector<int> ans;
        if (~j1) {
          for (int u = ls[j1]; ~u; u = par[u]) {
            ans.push_back(u);
          }
        }
        if (~j0) {
          for (int u = ls[j0]; indeg[u] <= 1; u = par[u]) {
            ans.push_back(u);
          }
        }
        return ans;
      }
    }
  }
}