while len(node.children)>0:

		b=node.getProp("B")

		w=node.getProp("W")

		# else: yield None # !! not really robust

		node=node.children[0]

		# draw current state

		for lineNumber,line in enumerate(self._game.board):

			for itemNumber,item in enumerate(line):

		# draw the moves

		for k in range(start,end):

			color,move=self._moves[k]

			if move==tuple():

				(c,r)=move

			if not self._move(color,c,r):

			# draw the move

			template.addMove(c,r,color,k+1)

		for i in range(k):

			(color,move)=self._moves[i]

			self._move(color,*move)

	def _move(self,color,c,r):

		elif os.path.isdir(item):

			files+=[os.path.join(item,child) for child in os.listdir(item)]

			print("contents of the '{0}' directory added to the queue".format(item))

def adjustFont(base,text):

	text=str(text)

class Svg(Base):

	'''

		for i in range(3):

			for j in range(3):

				self.content+=r'''  \filldraw[fill=black] ({0}\boardSquare,{1}\boardSquare) circle[radius=0.04];'''.format(6*i+3, 6*j+3)+'\n'

	def drawMove(self,x,y,label,color):

		fill="black" if color=="b" else "white"

		labelColor="white" if color=="b" else "black"

		self.content+=r'  \filldraw[draw=black,fill={0}] ({1}\boardSquare,{2}\boardSquare) circle[radius=0.5\boardSquare] node[color={3}]{{{4}}};'.format(fill,x,18-y,labelColor,label)+'\n'

		self.moveCount=0

	def move(self,color,y,x):

		self.board[x][y]=color

		for i,j in ((-1,0),(1,0),(0,-1),(0,1)):

			self.temp=[[False]*19 for i in range(19)]

		self.temp=[[False]*19 for i in range(19)]

		if not self._floodFill(color,x,y):

			self.board[x][y]=EMPTY

		return True

	def _floodFill(self,color,x,y):

		self.temp[x][y]=True

	def _remove(self):

		for i in range(19):

			for j in range(19):

def skipWhitespace(s,start):

	i=start

	return i

def strRowCol(s, i):

	k=0

	for (r,line) in enumerate(s.splitlines(True)):

		c=i-k

		if k+len(line)>i:

class ParserError(Exception):

	def __init__(self,msg,s,i):

		self.msg=msg

		self.context=s[i:i+16]

	def __str__(self):

	def __init__(self,s):

		self.gameTrees=[]

		i=skipWhitespace(s,0)

		elif not GameTree.fits(s,i):

			raise ParserError("expected a GameTree starting with '('",s,i)

		while GameTree.fits(s,i):

			self.gameTrees.append(x)

		if i<len(s):

			raise ParserError("expected EOF",s,i)

	def listGames(self):

		for tree in self.gameTrees:

class GameTree:

		y=None

		while Node.fits(s,i):

			res.nodes.append(x)

			x.parent=y

			y=x

			i=skipWhitespace(s,i)

		while GameTree.fits(s,i):

			res.branches.append(x)

			subroot=x.getNode(0)

			subroot.parent=y

			i=skipWhitespace(s,i)

		if i>=len(s) or s[i]!=")":

			raise ParserError("expected end of a GameTree marked by ')'",s,i)

		i=skipWhitespace(s,i+1)

	## Expand multiple games into distinct GameTrees and yield each.

	def listGames(self):

		for node in self.nodes[0].listGINodes():

			yield GameRecord(self._buildSubtree(node))

		i=skipWhitespace(s,start+1)

		while Property.fits(s,i):

			if x.name in res.properties:

				log.warning(ParserWarning('duplicate "{0}" property in a node. second value ignored'.format(x.name),s,i))

			else:

		return (i,res)

	def listGINodes(self):

		empty=not self.isGINode()

		node=self

				empty=False

				yield node

			queue.extend(node.children)

	def isGINode(self):

		return any(prop.type==GAME_INFO for prop in self.properties.values())

	def setProp(self,name,value):

		self.properties[name]=value

	def setChildren(self,children):

		self.children=children

	def addChild(self,node):

		node.parent=self

		self.children.append(node)

		return node

		return res

	def getProp(self,name,default=None):

	## Returns textual representation of the Node itself, but disregards its children.

	def __str__(self):

		output=[]

		while len(stack)>0:

			output.append(str(node)+"\n")

			childCount=len(node.children)

			else: # a branching node

				# first child pops first, last child closes parent's parentheses

				children=zip(node.children,[1]*childCount,[1]*(childCount-1)+[1+right])

		return "".join(output)

	def f(s,start):

		for vType in vTypes:

			try:

				return (i,x)

		raise ParserError("no variant of a 'choose' property value matched",s,start)

	return f

	def f(s,start):

		if not singletonFits(s,start):

			raise ParserError("expected a property value starting with '['",s,start)

		if not singletonEnds(s,i):

			raise ParserError("expected a property value ending with ']'",s,i)

		i=skipWhitespace(s,i+1)

			i=skipWhitespace(s,i+2)

			return (i,[])

		single=singleton(vType)

		res=[x]

		while singletonFits(s,i):

			res.append(x)

		return (i,res)

	return f

def compose(vTypeA,vTypeB):

	def f(s,start):

		if i>=len(s) or s[i]!=":":

			raise ParserError("expected a composed property value separated by ':'",s,i)

		return (i,Composed(a,b))

	return f

def number(s,start):

	m=Regexp.number.match(s,start)

	res=int(m.group(0))

	return (m.end(),res)

def real(s,start):

	m=Regexp.real.match(s,start)

	res=float(m.group(0))

	return (m.end(),res)

	return f

def anything(s,start):

	esc=False

	i=start

		if esc: esc=False

		elif c=="\\": esc=True

		elif c=="]": break

# go specific

def point(s,start):

	m=Regexp.point.match(s,start) # !! limit to board size

	if m.group(0)=="": # pass, !! tt

		return (m.end(),tuple())

	col=m.group(0)[0]

	def create(s,start):

		assert Property.fits(s,start)

		res=Property()

		i=skipWhitespace(s,i)

		try:

			log.warning(e)

			res.name="_"+res.name

		res.value=x

		if res.name=="DT":

	@staticmethod

	def ident(s,start):

		m=Property.identRegexp.match(s,start)

		return (m.end(),m.group())

	@staticmethod

	@property

	def type(self):

		gameInfo={"AN","BR","BT","CP","DT","EV","GN","GC","ON","OT","PB","PC","PW","RE","RO","RU","SO","TM","US","WR","WT"}

	def copy(self):

		res=Property()

	def __str__(self):

		name=self.name.lstrip("_")

		return "{0}{1}".format(name,val)

	patterns={

		if len(tokens)==3:

			return ("YMD",date(*num_tokens))

		elif len(tokens)==2:

		else:

		with self.assertRaises(AssertionError):

			Property.create("99[99]",0)

		self.assertNotEqual((i,prop), (0,None))

		self.assertEqual((i,prop.name), (6,"MN"))

		with open(os.path.join(dataDir, "kogos.sgf")) as f:

			Collection(f.read())

if __name__ == '__main__':

	unittest.main()