Problem:
Score : 700 points

Problem Statement

You are given an integer L. Construct a directed graph that satisfies the conditions below. The graph may contain multiple edges between the same pair of vertices. It can be proved that such a graph always exists.

The number of vertices, N, is at most 20. The vertices are given ID numbers from 1 to N.

The number of edges, M, is at most 60. Each edge has an integer length between 0 and 10^6 (inclusive).

Every edge is directed from the vertex with the smaller ID to the vertex with the larger ID. That is, 1,2,...,N is one possible topological order of the vertices.

There are exactly L different paths from Vertex 1 to Vertex N. The lengths of these paths are all different, and they are integers between 0 and L-1.

Here, the length of a path is the sum of the lengths of the edges contained in that path, and two paths are considered different when the sets of the edges contained in those paths are different.

Constraints

2 \leq L \leq 10^6

L is an integer.

Input

Input is given from Standard Input in the following format:

L

Output

In the first line, print N and M, the number of the vertices and edges in your graph.
In the i-th of the following M lines, print three integers u_i,v_i and w_i, representing the starting vertex, the ending vertex and the length of the i-th edge.
If there are multiple solutions, any of them will be accepted.

Sample Input 1

4

Sample Output 1

8 10
1 2 0
2 3 0
3 4 0
1 5 0
2 6 0
3 7 0
4 8 0
5 6 1
6 7 1
7 8 1

In the graph represented by the sample output, there are four paths from Vertex 1 to N=8:

1 → 2 → 3 → 4 → 8 with length 0

1 → 2 → 3 → 7 → 8 with length 1

1 → 2 → 6 → 7 → 8 with length 2

1 → 5 → 6 → 7 → 8 with length 3

There are other possible solutions.

Sample Input 2

5

Sample Output 2

5 7
1 2 0
2 3 1
3 4 0
4 5 0
2 4 0
1 3 3
3 5 1

Solution in C++ (Clang 10.0.0) (judge verdict: Runtime Error)

#include<cstdio>
#include<vector>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<queue>
#define limp 20
#define limq 65
struct graph
{
	struct edge
	{
		int x,y,v,w;
	};
	std::vector<int> a[25];
	std::vector<edge> g;
	std::vector< std::pair<int,int> > pre;
	const int val[105]={0,0,0,0,0,0,1,1,2,3,3,3,5,5,5,7,8,8,9,9,11,11,11,11,14,15,15,15,17,17,19};
	int opt,start,end,p,q,n,f[25],w[25],h[105][105],cnt[25][105],ww[105][105],id[105],in[105],used[105],pp[105];
	void add(int x,int y,int v,int w)
	{
		g.push_back(edge{x,y,v,w});
	}
	void add_edge(int x,int y)
	{
		a[x].push_back(y);
	}
	int check()
	{
		return p<=limp&&q<=limq;
	}
	void toposort(int s)
	{
	    int now=0;
		for (int i=0;i<g.size();i++)
		{
			edge u=g[i];
			add_edge(u.x,u.y);
			++in[u.y];
		}
		std::queue<int> q;
	    for (int i=1;i<=p;i++) if (!in[i]&&!used[i]) id[i]=++now,q.push(i);
	    while (!q.empty())
        {
        	int v=q.front();q.pop();
        	for (int i=0;i<a[v].size();i++)
        	{
        		int u=a[v][i];
        		--in[u];
        		if (!in[u]) id[u]=++now,q.push(u);
			}
		}
    }
	int cansplit(int sz){return 6<=sz&&sz<=25;}
	void clean(int x,int k){for (int i=x;i<=x+k-1;i++) g[i].x=g[i].y=g[i].v=0;}
	std::pair<int,int> split6(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,3*w);
		add(x,p+1,3*w,3*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		++p;
		return std::make_pair(2,3);
	}
	std::pair<int,int> split7(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,3*w);
		add(x,p+1,3*w,3*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(x,y,6*w,w);
		++p;
		return std::make_pair(2,3);
	}
	std::pair<int,int> split8(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,4*w);
		add(x,p+1,4*w,4*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		++p;
		return std::make_pair(2,4);
	}
	std::pair<int,int> split9(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,3*w);
		add(x,p+1,3*w,3*w);
		add(x,p+1,6*w,3*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		++p;
		return std::make_pair(3,3);
	}
	std::pair<int,int> split10(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,5*w);
		add(x,p+1,5*w,5*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		++p;
		return std::make_pair(2,5);
	}
	std::pair<int,int> split11(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,5*w);
		add(x,p+1,5*w,5*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		add(x,y,10*w,w);
		++p;
		return std::make_pair(2,5);
	}
	std::pair<int,int> split12(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,4*w);
		add(x,p+1,4*w,4*w);
		add(x,p+1,8*w,4*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		++p;
		return std::make_pair(3,4);
	}
	std::pair<int,int> split13(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,4*w);
		add(x,p+1,4*w,4*w);
		add(x,p+1,8*w,4*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(x,y,12*w,w);
		++p;
		return std::make_pair(3,4);
	}
	std::pair<int,int> split14(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,7*w);
		add(x,p+1,7*w,7*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		add(p+1,y,5*w,w);
		add(p+1,y,6*w,w);
		++p;
		return std::make_pair(2,7);
	}
	std::pair<int,int> split15(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,5*w);
		add(x,p+1,5*w,5*w);
		add(x,p+1,10*w,5*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		++p;
		return std::make_pair(3,5);
	}
	std::pair<int,int> split16(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,4*w);
		add(x,p+1,4*w,4*w);
		add(x,p+1,8*w,4*w);
		add(x,p+1,12*w,4*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		++p;
		return std::make_pair(4,4);
	}
	std::pair<int,int> split17(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,4*w);
		add(x,p+1,4*w,4*w);
		add(x,p+1,8*w,4*w);
		add(x,p+1,12*w,4*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(x,y,16*w,w);
		++p;
		return std::make_pair(4,4);
	}
	std::pair<int,int> split18(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,3*w);
		add(x,p+1,6*w,3*w);
		add(x,p+1,12*w,3*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		add(p+1,y,5*w,w);
		++p;
		return std::make_pair(3,6);
	}
	std::pair<int,int> split19(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,6*w);
		add(x,p+1,6*w,6*w);
		add(x,p+1,12*w,6*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		add(p+1,y,5*w,w);
		add(x,y,18*w,w);
		++p;
		return std::make_pair(3,6);
	}
	std::pair<int,int> split20(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,w);
		add(x,p+1,5*w,5*w);
		add(x,p+1,10*w,5*w);
		add(x,p+1,15*w,5*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		++p;
		return std::make_pair(4,5);
	}
	std::pair<int,int> split21(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,7*w);
		add(x,p+1,7*w,7*w);
		add(x,p+1,14*w,7*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		add(p+1,y,5*w,w);
		add(p+1,y,6*w,w);
		++p;
		return std::make_pair(3,7);
	}
	std::pair<int,int> split22(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,7*w);
		add(x,p+1,7*w,7*w);
		add(x,p+1,14*w,7*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		add(p+1,y,5*w,w);
		add(p+1,y,6*w,w);
		add(x,y,21*w,w);
		++p;
		return std::make_pair(3,7);
	}
	std::pair<int,int> split23(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,7*w);
		add(x,p+1,7*w,7*w);
		add(x,p+1,14*w,7*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		add(p+1,y,5*w,w);
		add(p+1,y,6*w,w);
		add(x,y,21*w,w);
		add(x,y,22*w,w);
		++p;
		return std::make_pair(3,7);
	}
	std::pair<int,int> split24(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,6*w);
		add(x,p+1,6*w,6*w);
		add(x,p+1,12*w,6*w);
		add(x,p+1,18*w,6*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		add(p+1,y,5*w,w);
		++p;
		return std::make_pair(4,6);
	}
	std::pair<int,int> split25(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,5*w);
		add(x,p+1,5*w,5*w);
		add(x,p+1,10*w,5*w);
		add(x,p+1,15*w,5*w);
		add(x,p+1,20*w,5*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		++p;
		return std::make_pair(5,5);
	}
	std::pair<int,int> split26(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,5*w);
		add(x,p+1,5*w,5*w);
		add(x,p+1,10*w,5*w);
		add(x,p+1,15*w,5*w);
		add(x,p+1,20*w,5*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		add(x,y,25*w,w);
		++p;
		return std::make_pair(5,5);
	}
	std::pair<int,int> split27(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,9*w);
		add(x,p+1,9*w,9*w);
		add(p+1,y,18*w,9*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		add(p+1,y,5*w,w);
		add(p+1,y,6*w,w);
		add(p+1,y,7*w,w);
		add(p+1,y,8*w,w);
		++p;
		return std::make_pair(3,9);
	}
	std::pair<int,int> split28(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,7*w);
		add(x,p+1,7*w,7*w);
		add(p+1,y,14*w,7*w);
		add(p+1,y,21*w,7*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		add(p+1,y,5*w,w);
		add(p+1,y,6*w,w);
		++p;
		return std::make_pair(4,7);
	}
	std::pair<int,int> split29(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,7*w);
		add(x,p+1,7*w,7*w);
		add(p+1,y,14*w,7*w);
		add(p+1,y,21*w,7*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		add(p+1,y,5*w,w);
		add(p+1,y,6*w,w);
		add(x,y,28*w,w);
		++p;
		return std::make_pair(4,7);
	}
	std::pair<int,int> split30(int x,int y,int sz,int w)
	{
		int v=p+1;
		clean(h[x][y],sz);
		add(x,p+1,0*w,6*w);
		add(x,p+1,6*w,6*w);
		add(p+1,y,12*w,6*w);
		add(p+1,y,18*w,6*w);
		add(p+1,y,24*w,6*w);
		add(p+1,y,0*w,w);
		add(p+1,y,1*w,w);
		add(p+1,y,2*w,w);
		add(p+1,y,3*w,w);
		add(p+1,y,4*w,w);
		add(p+1,y,5*w,w);
		++p;
		return std::make_pair(5,6);
	}
	std::pair<int,int> split(int x,int y,int sz,int w)
	{
//		printf("split %d %d %d %d\n",x,y,sz,w);
		if (sz==6) return split6(x,y,sz,w);
		if (sz==7) return split7(x,y,sz,w);
		if (sz==8) return split8(x,y,sz,w);
		if (sz==9) return split9(x,y,sz,w);
		if (sz==10) return split10(x,y,sz,w);
		if (sz==11) return split11(x,y,sz,w);
		if (sz==12) return split12(x,y,sz,w);
		if (sz==13) return split13(x,y,sz,w);
		if (sz==14) return split14(x,y,sz,w);
		if (sz==15) return split15(x,y,sz,w);
		if (sz==16) return split16(x,y,sz,w);
		if (sz==17) return split17(x,y,sz,w);
		if (sz==18) return split18(x,y,sz,w);
		if (sz==19) return split19(x,y,sz,w);
		if (sz==20) return split20(x,y,sz,w);
		if (sz==21) return split21(x,y,sz,w);
		if (sz==22) return split22(x,y,sz,w);
		if (sz==23) return split23(x,y,sz,w);
		if (sz==24) return split24(x,y,sz,w);
		if (sz==25) return split25(x,y,sz,w);
	}
	void adjust()
	{
		std::vector<edge> tmp;
		for (int i=0;i<g.size();i++) if (g[i].x&&g[i].y) tmp.push_back(g[i]);
		g.clear();
		for (int i=0;i<tmp.size();i++) g.push_back(tmp[i]);
		q=g.size();
	}
	int cmp(std::pair<int,int> p,std::pair<int,int> q)
	{
		int x1=p.first,y1=p.second,x2=q.first,y2=q.second;
		return val[cnt[x1][y1]]>val[cnt[x2][y2]];
	}
	void relabel()
	{
		std::vector<edge> tmp;
		toposort(1);
		for (int i=0;i<g.size();i++) tmp.push_back(edge{id[g[i].x],id[g[i].y],g[i].v,g[i].w});
		g.clear();
		for (int i=0;i<tmp.size();i++) g.push_back(tmp[i]);
		q=g.size();
		int del=0;
		for (int i=1;i<=p;i++) if (used[i]) ++del;
		p=p-del;
	}
	void combine(int x,int k)
	{
		if (!g[k].x) return;
		printf("combine %d %d\n",x,k);
//		if (g[k].y!=x) puts("no");
		used[x]=1;
		for (int i=0;i<g.size();i++)
		{
			if (g[i].x==x) add(g[k].x,g[i].y,g[k].v+g[i].v,g[i].w);
		    g[i].x=g[i].y=g[i].v=g[i].w=0;
		}
		g[k].x=g[k].y=g[k].v=g[k].w=0;
		x=0;    
	}
	int merge()
	{
		for (int i=1;i<=p;i++) pp[i]=in[i]=0;
		for (int i=0;i<g.size();i++)
		{
			int xx=g[i].x,yy=g[i].y;
			++in[yy];pp[yy]=i;
		}
		for (int i=1;i<=p;i++) printf("%d\n",in[i]);
		for (int i=1;i<=p;i++) if (in[i]==1) combine(i,pp[i]);
		for (int i=1;i<=p;i++) pp[i]=in[i]=0;
	}
	void remake(int base)
	{
		opt=0;
		std::priority_queue< std::pair<int,std::pair<int,int> > > pq;
		int start=1,end=p;
		for (int i=0;i<g.size();i++)
		{
			int xx=g[i].x,yy=g[i].y;
			++cnt[xx][yy];
			ww[xx][yy]=g[i].w;
			if (cnt[xx][yy]==1) h[xx][yy]=i;
		}
//		puts("cnt");
//		for (int i=1;i<=p;i++)
//		{
//			for (int j=1;j<=p;j++)
//			    printf("%d ",cnt[i][j]);
//			puts("");
//		}
		for (int i=1;i<=p;i++)
		    for (int j=1;j<=p;j++)
		        if (cansplit(cnt[i][j])) pq.push(std::make_pair(val[cnt[i][j]],std::make_pair(i,j)));
//		pre.push_back(std::make_pair(i,j));
		
//	    puts("qwq");
//		for (int i=0;i<pre.size();i++) printf("%d %d\n",pre[i].first,pre[i].second);puts("");
//        if (!pre.size()) return;
//		std::sort(pre.begin(),pre.end());
        int flag=0;
//        puts("qaq");
        int now=q;
		while (!pq.empty())
		{
			std::pair<int,int> v=pq.top().second;pq.pop();
		    if (p<limp)
			{
				int x1=v.first,y1=v.second;
				std::pair<int,int> r=split(x1,y1,cnt[x1][y1],ww[x1][y1]);
//				h[x1][p]=now;h[p][y1]=now+r.first;now=now+cnt[x1][y1]-val[cnt[x1][y1]];
				//if (cansplit(r.first)) pq.push(std::make_pair(val[r.first],std::make_pair(x1,p)));
				//if (cansplit(r.second)) pq.push(std::make_pair(val[r.second],std::make_pair(p,y1)));
				flag=1;
			}
	    }
	    opt=flag;
//	    puts("qwq");
//	    if (!flag) return;
		adjust();
//		printf("%d %d\n",end,p);
        for (int i=1;i<=n;i++) used[i]=0;
        print();
        opt=opt||merge();
        adjust();
        if (!opt) return;
		relabel();
	}
	void print()
	{
//		puts("-------");
		printf("%d %d\n",p,q);
		for (int i=0;i<g.size();i++) printf("%d %d %d\n",g[i].x,g[i].y,g[i].v);
//		puts("-------");
	}
	void trans(int x,int base)
	{
		n=0;
		while (x)
		{
			f[++n]=x%base;
			x=x/base;
		}
		w[1]=1;for (int i=2;i<=n;i++) w[i]=w[i-1]*base;
//		printf("f:");for (int i=1;i<=n;i++) printf("%d ",f[i]);puts("");
//		printf("w:");for (int i=1;i<=n;i++) printf("%d ",w[i]);puts("");
		for (int i=1;i<=n/2;i++) std::swap(f[i],f[n-i+1]),std::swap(w[i],w[n-i+1]);
	}
	void solve(int l,int base)
    {
	    trans(l,base);
		p=1,q=0;
		int k=0;
		for (k=n;k>=1;k--)
		{
			if (f[k]!=base-1||k==0) break;
			for (int j=0;j<base;j++) add(p,p+1,w[k]*j,w[k]),++q;
			p=p+1;
		}
		if (k==0) return;
		if (k==1)
		{
			for (int j=0;j<=f[1];j++) add(p,p+1,w[1]*j,w[1]),++q;
			p=p+1;
			return;
		}
		for (int i=1;i<=k;i++)
		{
			if (i==1)
			{
			    for (int j=0;j<f[i];j++) add(p,p+1,w[i]*j,w[i]),++q;
			    add(p,p+2,w[i]*f[i],w[i]),++q;
			    p=p+2;
			}
			else if (i==k)
			{
				for (int j=0;j<base;j++) add(p-1,p+1,w[i]*j,w[i]),++q;
				for (int j=0;j<=f[i];j++) add(p,p+1,w[i]*j,w[i]),++q;
				p=p+1;
			}
			else
			{
				for (int j=0;j<base;j++) add(p-1,p+1,w[i]*j,w[i]),++q;
				for (int j=0;j<f[i];j++) add(p,p+1,w[i]*j,w[i]),++q;
				add(p,p+2,w[i]*f[i],w[i]);++q;
				p=p+2;
			}
		}
	}
};
graph c[70];
int l;
int main()
{
	scanf("%d",&l);
//	printf("%d\n",l);
	for (int i=2;i<=60;i++)
	{
		c[i].solve(l-1,i);
//		if (c[i].check())
//		{
////			printf("base:%d\n",i);
//			c[i].print();
//			return 0;
//		}
//	    else
		{
			c[i].opt=1;
			while (c[i].opt) c[i].remake(i);
			if (c[i].check())
			{
//				printf("base:%d\n",i);
				c[i].print();
				return 0;
			}
//			return 0;
		}	
    }
	return 0;
}