//
// Given a round robin schedule, that respects last/first in round constraint
// orient matches such that for a skipper he spends as much time port as
// starboard and does not have 3 consecutive matches in the same orientation
//
import java.util.*;
import java.io.*;
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.model.constraints.automaton.DFA;
import choco.kernel.model.constraints.automaton.Transition;

public class Phase1b {
    Model model;  
    Solver solver; 
    int n, rounds, boats;
    int[][] schedule;        // constant, schedule[i][j] = k <-> match(i,j) at timeslot k
    Round[] round;           // an array of rounds
    Skipper[] skipper;       // an array of skippers
    int matchesPerRound;     // the maximum number of matches in a round (boats/2)

    Phase1b (String fname) throws IOException {
	Scanner sc      = new Scanner(new File(fname));
	n               = sc.nextInt();                // number of skippers
	rounds          = sc.nextInt();                // number of rounds
	boats           = sc.nextInt();                // number of boats
	schedule        = new int[n][n];               // as read in
	round           = new Round[rounds];
	skipper         = new Skipper[n];
	model           = new CPModel();
	solver          = new CPSolver();
	matchesPerRound = boats/2;                     // of course

	for (int i=0;i<n;i++)
	    for (int j=0;j<n;j++)
		schedule[i][j]  = sc.nextInt(); // timeslot for match(i,j)
	sc.close();
	//
	// read in schedule
	//

	for (int i=0;i<rounds;i++) round[i] = new Round(i,boats);
	for (int i=0;i<n;i++) skipper[i] = new Skipper(i,n-1,boats);
	for (int i=0;i<n-1;i++)
	    for (int j=i+1;j<n;j++){
		int timeSlot = schedule[i][j];
		Match m = new Match(i,j,timeSlot);
		model.addConstraint(neq(m.boat1,m.boat2)); // port or straboard
		int r = schedule[i][j]/matchesPerRound;
		round[r].add(m);
		skipper[i].add(m);
		skipper[j].add(m);
	    }
	//
	// from the schedule produce the matches and add these
	// to the appropraite rounds and skippers
	//

	List<Transition> t = new LinkedList<Transition>();
	t.add(new Transition(0,0,1));
	t.add(new Transition(0,1,2));
	t.add(new Transition(1,0,3));
	t.add(new Transition(1,1,2));
	t.add(new Transition(2,1,4));
	t.add(new Transition(2,0,1));
	t.add(new Transition(3,1,2));
	t.add(new Transition(4,0,1));
	//
	// Deterministic Finite Automat0n that accepts strings
	// from alphabet {0,1} that do not contain *000* or *111*
	//

	List<Integer> fs = new LinkedList<Integer>();
	fs.add(0); 
	fs.add(1); fs.add(2); fs.add(3); fs.add(4);
	//
	// list of accepting states, in this case all but the start state 0
	//
	DFA auto = new DFA(t,fs,n-1);


	for (int i=0;i<n;i++)
	    skipper[i].portStarboard(model,auto);
	//
	// for each skipper
	//    order matches chronologically
	//    impose port/straboard pattern
	//    balance port/starboard
	//

	solver.read(model);	
    }

    void output(){
	/*
	MatchComparator MC = new MatchComparator();
	for (Round r : round){
	    Collections.sort(r.match,MC);
	    for (Match m : r.match)
		System.out.print("(s"+ m.player1 +"/b"+ solver.getVar(m.boat1).getVal() +",s"+
				 m.player2 +"/b"+ solver.getVar(m.boat2).getVal() +") ");
	    System.out.println();
	}
	*/
	for (Skipper s : skipper){
	    System.out.print("skipper_"+s.id +" -> ");
	    for (IntegerVariable b : s.boat) System.out.print(solver.getVar(b).getVal() +" ");
	    System.out.println();
	}	
    }                                  

    //boolean minimize(){return solver.minimize(solver.getVar(changes),false);}

    boolean solve(){return solver.solve();}

    void stats(){
	System.out.println("nodes: "+ solver.getNodeCount() +"   cpu: "+ solver.getTimeCount());
    }
    
    public static void main(String[] args)  throws IOException {
	Phase1b orientBoats = new Phase1b (args[0]);
	int timeout = 0;
	if (args.length > 1) orientBoats.solver.setTimeLimit(Integer.parseInt(args[1]) * 1000);
	//System.out.println(orientBoats.minimize());
	System.out.println(orientBoats.solve());
	orientBoats.stats();
	orientBoats.output();        
    }
}