def splitBDD(BDD,c1):
	if len(BDD.data) > c1-1:
		#print type(BDD),type(BDD.cutval),type(BDD.dimCutVal),type(BDD.data),type(BDD.n1),type(BDD.n2),type(BDD.LE),type(BDD.LEM)################
		cutVals = C2_criterion(BDD)
		BDD.n1 = tree.node(-1,-1,[],None,None,[],[])
		BDD.n2 = tree.node(-1,-1,[],None,None,[],[])
		for x in range(0,c1-1):
			if(BDD.data[x][cutVals[1]] <= cutVals[0]):
				BDD.n1.data.append(BDD.data[x])
			else:
				BDD.n2.data.append(BDD.data[x])
				pass
			pass
		BDD.cutval = cutVals[0]
		BDD.dimCutVal = cutVals[1]

		BDD.n1.LE = copy(BDD.LE)
		BDD.n1.LEM = copy(BDD.LEM)
		BDD.n2.LE = copy(BDD.LE)
		BDD.n2.LEM = copy(BDD.LEM)

		#supp de DATA LE et LEM du pere
		BDD.LE = []
		BDD.LEM = []
		BDD.data = []
	else:
		pass

def getMove(board, roll):

    validMoves = moveGen.getMoves(board, roll, 1)
    treeRoots = []
    #print validMoves
    for validMove in validMoves:
        root = tree.node()
        root.name = str(validMove)
        root.move = validMove
        newBoard = move(board, validMove[0][0], validMove[0][1], 1)
        newBoard = move(newBoard, validMove[1][0], validMove[1][1], 1)
        root.board = newBoard
        root.roll = roll
        treeRoots.append(root)

# What complete is essentaily the first max level
# So min first then max
# Each level should then consist of a call to the min max function
# Which will min then max
    highest = tree.node()
    for root in treeRoots:
        minMax(root)
        #print root.score
        #print root.name
        if root.score > highest.score:
            highest = root
    return highest.move

def ProcName(father):
	global lookahead, token_list, node

	PROCNAME = node()
	nt_init(father, PROCNAME, "ProcName", [])

	if match("id"):
		T_ID = node()
		t_init(PROCNAME, T_ID, lookahead[1], [])

def Top(father):
	global lookahead, token_list, node

	TOP = node()
	nt_init(father, TOP, "Top", [])

	if match("intc"):
		T_INTC = node()
		t_init(TOP, T_INTC, lookahead[1], [])

def Low(father):
	global lookahead, token_list, node

	LOW = node()
	nt_init(father, LOW, "Low", [])

	if match("intc"):
		T_INTC = node()
		t_init(LOW, T_INTC, lookahead[1], [])

def Invar(father):
	global lookahead, token_list, node

	INVAR = node()
	nt_init(father, INVAR, "Invar", [])

	if match("id"):
		T_ID = node()
		t_init(INVAR, T_ID, lookahead[1], [])

def TypeId(father):
	global lookahead, token_list, node

	TYPEID = node()
	nt_init(father, TYPEID, "TypeId", [])

	if match("id"):
		T_ID = node()
		t_init(TYPEID, T_ID, lookahead[1], [])

def ReturnStm(father):
	global lookahead, token_list, node

	RETURNSTM = node()
	nt_init(father, RETURNSTM, "ReturnStm", [])

	if match("return"):
		T_RETURN = node()
		t_init(RETURNSTM, T_RETURN, "return", [])

def IdList(father):
	global lookahead, token_list, node

	IDLIST = node()
	nt_init(father, IDLIST, "IdList", [])

	if match("id"):
		T_ID = node()
		t_init(IDLIST, T_ID, lookahead[1], [])
	IdMore(IDLIST)

def ProgramHead(father):
	global lookahead, token_list, node

	PROGRAMHEAD = node()
	nt_init(father, PROGRAMHEAD, "ProgramHead", [])

	if match("program"):
		T_PROGRAM = node()
		t_init(PROGRAMHEAD, T_PROGRAM, "program", [])
	ProgramName(PROGRAMHEAD)

def VarDec(father):
	global lookahead, token_list, node

	VARDEC = node()
	nt_init(father, VARDEC, "VarDec", [])

	if match("var"):
		T_VAR = node()
		t_init(VARDEC, T_VAR, "var", [])
	VarDecList(VARDEC)

def VarIdList(father):
	global lookahead, token_list, node

	VARIDLIST = node()
	nt_init(father, VARIDLIST, "VarIdList", [])

	if match("id"):
		T_ID = node()
		t_init(VARIDLIST, T_ID, lookahead[1], [])
	VarIdMore(VARIDLIST)

def Variable(father):
	global lookahead, token_list, node

	VARIABLE = node()
	nt_init(father, VARIABLE, "Variable", [])

	if match("id"):
		T_ID = node()
		t_init(VARIABLE, T_ID, lookahead[1], [])
	VariMore(VARIABLE)

def FieldVar(father):
	global lookahead, token_list, node

	FIELDVAR = node()
	nt_init(father, FIELDVAR, "FieldVar", [])

	if match("id"):
		T_ID = node()
		t_init(FIELDVAR, T_ID, lookahead[1], [])
	FieldVarMore(FIELDVAR)

def FormList(father):
	global lookahead, token_list, node

	FORMLIST = node()
	nt_init(father, FORMLIST, "FormList", [])

	if match("id"):
		T_ID = node()
		t_init(FORMLIST, T_ID, lookahead[1], [])
	FidMore(FORMLIST)

def ProcDecMore(father):
	global lookahead, token_list, node

	PROCDECMORE = node()
	nt_init(father, PROCDECMORE, "ProcDecMore", [])

	if lookahead[1] == "procedure":
		ProcDec(PROCDECMORE)
	else:
		T_VOID = node()
		t_init(PROCDECMORE, T_VOID, "ε", [])

def ProcDecpart(father):
	global lookahead, token_list, node

	PROCDECPART = node()
	nt_init(father, PROCDECPART, "ProcDecpart", [])

	if lookahead[1] == "procedure":
		ProcDec(PROCDECPART)
	else:
		T_VOID = node()
		t_init(PROCDECPART, T_VOID, "ε", [])

def VarDecPart(father):
	global lookahead, token_list, node

	VARDECPART = node()
	nt_init(father, VARDECPART, "VarDecPart", [])

	if lookahead[1] == "var":
		VarDec(VARDECPART)
	else:
		T_VOID = node()
		t_init(VARDECPART, T_VOID, "ε", [])

def TypeDecMore(father):
	global lookahead, token_list, node

	TYPEDECMORE = node()
	nt_init(father, TYPEDECMORE, "TypeDecMore", [])

	if lookahead[2] == "id":
		TypeDecList(TYPEDECMORE)
	else:
		T_VOID = node()
		t_init(TYPEDECMORE, T_VOID, "ε", [])

def AssignmentRest(father):
	global lookahead, token_list, node

	ASSIGNMENTREST = node()
	nt_init(father, ASSIGNMENTREST, "AssignmentRest", [])

	VariMore(ASSIGNMENTREST)
	if match(":="):
		T_ASSIGNMENT = node()
		t_init(ASSIGNMENTREST, T_ASSIGNMENT, ":=", [])
	Exp(ASSIGNMENTREST)