//
// 3-valued, symmetry breaking as in IJCAI2013, value and variable ordering
//
import java.io.*;
import java.util.*;
import static choco.Choco.*;
import choco.cp.model.CPModel;
import choco.cp.solver.CPSolver;
import choco.kernel.model.Model;
import choco.kernel.solver.Solver;
import choco.kernel.model.variables.integer.IntegerVariable;
import choco.kernel.solver.variables.integer.IntDomainVar;
import choco.kernel.solver.ContradictionException;
import choco.cp.solver.search.integer.varselector.StaticVarOrder;
import choco.cp.solver.search.integer.varselector.MinDomain;
import choco.cp.solver.search.integer.valiterator.DecreasingDomain;

public class Ramsey334_30b {

    private static void symBreak(int lwb,int upb,Model model,IntegerVariable[][] A){
	int n = A.length;
	for (int i=lwb;i<upb;i++){
	    IntegerVariable [] X = new IntegerVariable[n-2];
	    IntegerVariable [] Y = new IntegerVariable[n-2];
	    for (int j=0;j<i;j++) X[j] = A[i][j];
	    for (int j=i+2;j<n;j++) X[j-2] = A[i][j];
	    for (int j=0;j<i;j++) Y[j] = A[i+1][j];
	    for (int j=i+2;j<n;j++) Y[j-2] = A[i+1][j];
	    model.addConstraint(lexeq(X,Y));
	}
    }

    public static void main(String[] args){

	int n                     = 30;
	int REDDEG                = Integer.parseInt(args[0]);
	int BLUEDEG               = Integer.parseInt(args[1]);
	int GREENDEG              = Integer.parseInt(args[2]);
	Model model               = new CPModel();
	Solver solver             = new CPSolver();
	IntegerVariable[][] A     = new IntegerVariable[n][n]; 
	IntegerVariable[] flatA   = new IntegerVariable[n*(n-1)/2];
	int RED                   = 0;
	int BLUE                  = 1;
	int GREEN                 = 2;
	int NOCOLOUR              = -1;

	/////////////////////////////////////////////////////////////////////////////////
	//                      3 valued model with one array A                        //
	/////////////////////////////////////////////////////////////////////////////////
	
	for (int i=0,k=0;i<n-1;i++){
	    for (int j=i+1;j<n;j++,k++)
		flatA[k] = A[i][j] = A[j][i] = makeIntVar("A_"+ i +"_"+ j,0,2);
	}

	for (int i=0;i<n;i++) A[i][i] = constant(NOCOLOUR);
	
	for (int i=0;i<n-2;i++)
	    for (int j=i+1;j<n-1;j++)
		for (int k=j+1;k<n;k++){
		    IntegerVariable[] edges = {A[i][j],A[i][k],A[j][k]};
		    IntegerVariable redCount = makeIntVar("redCount",0,2);
		    model.addConstraint(occurrence(RED,redCount,edges));
		    IntegerVariable blueCount = makeIntVar("blueCount",0,2);
		    model.addConstraint(occurrence(BLUE,blueCount,edges));
		}
	//
	// no RED or BLUE triangles
	//

	for (int h=0;h<n-3;h++)
	    for (int i=h+1;i<n-2;i++)
		for (int j=i+1;j<n-1;j++)
		    for (int k=j+1;k<n;k++){
			IntegerVariable[] edges    = {A[h][i],A[h][j],A[h][k],A[i][j],A[i][k],A[j][k]};
			IntegerVariable greenCount = makeIntVar("greenCount",0,5);
			model.addConstraint(occurrence(GREEN,greenCount,edges));
		    }
	//
	// no GREEN K4
	//

	/////////////////////////////////////////////////////////////////////////////////
	//                              additional constraints                         //
	/////////////////////////////////////////////////////////////////////////////////

	//for (int i=0;i<24;i++) model.addConstraint(lexeq(A[i],A[i+1]));
	symBreak(0,24,model,A);
	//
	// sym breaker on 1st 25 vertices
	//

	for (int i=0;i<25;i++){
	    model.addConstraint(occurrence(RED,constant(8),A[i]));
	    model.addConstraint(occurrence(BLUE,constant(8),A[i]));
	    model.addConstraint(occurrence(GREEN,constant(13),A[i]));
	}
	//
	// first 25 vertices, each has 8 red edges, 8 blue edges and 13 green edges
	//

	for (int i=25;i<n-1;i++)
	    for (int j=i+1;j<n;j++)
		model.addConstraint(implies(eq(A[i][j],GREEN),
					    or(occurrence(GREEN,constant(13),A[i]),
					       occurrence(GREEN,constant(13),A[j]))));
	//
	// every green edge (i,j) has at least one endpoint i or j such that the number of 
        // green edges incident on it is 13, i.e. sum(green[i]) = 13 or sum(green[j]) = 13
	//

	model.addConstraint(occurrence(RED,constant(REDDEG),A[25]));
	model.addConstraint(occurrence(BLUE,constant(BLUEDEG),A[25]));
	model.addConstraint(occurrence(GREEN,constant(GREENDEG),A[25]));
	//
	// fix degrees on vertex 25 for reduced problem
	//

	//for (int i=26;i<n-1;i++) model.addConstraint(lexeq(A[i],A[i+1]));
	symBreak(26,n-1,model,A);
	//model.addConstraint(eq(A[0][1],RED));
	//
	// sym breaker on vertices 26, 27, 28 and 29
	//

	/////////////////////////////////////////////////////////////////////////////////
	//                 solve it! (or wait for alien invasion)                      //
	/////////////////////////////////////////////////////////////////////////////////

	solver.read(model);
	solver.setVarIntSelector(new MinDomain(solver,solver.getVar(flatA)));
	solver.setValIntIterator(new DecreasingDomain());
	if (solver.solve().booleanValue()){
	    for (int i=0;i<n;i++){
		for (int j=0;j<n;j++)
		    if (i==j) System.out.print(" "); else System.out.print(solver.getVar(A[i][j]).getVal());
		System.out.println();
	    }
	}
	else System.out.println("false");
	solver.printRuntimeSatistics();
    }
}