#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;
      if (lsLen == 0) {
        assert(false);
      } else if (lsLen <= 2) {
        vector<int> paths[2];
        for (int j = 0; j < lsLen; ++j) {
          for (int u = ls[j]; ~u; u = par[u]) {
            paths[j].push_back(u);
          }
        }
        auto ans = paths[0];
        if (lsLen == 2) {
          paths[1].pop_back();
          reverse(paths[1].begin(), paths[1].end());
          ans.insert(ans.end(), paths[1].begin(), paths[1].end());
        }
        return ans;
      } else {
        int j0 = -1, j1 = -1;
        for (j0 = 0; j0 < 3; ++j0) for (j1 = j0 + 1; j1 < 3; ++j1) {
          if (A[ls[j0]][ls[j1]]) {
            goto found;
          }
        }
        assert(false);
       found:{}
        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;
        }
      }
    }
  }
}