diff --git a/src/go/engine.py b/src/go/engine.py
--- a/src/go/engine.py
+++ b/src/go/engine.py
@@ -1,4 +1,5 @@
-import core
+from util import EMPTY,BLACK,WHITE
+from . import core
 
 
 def transitionSequence(state1, state2, diff, limit=0):
@@ -6,8 +7,8 @@ def transitionSequence(state1, state2, d
 
 
 class SpecGo(core.Go):
-	def __init__(self):
-		super().__init__()
+	def __init__(self,boardSize=19):
+		super().__init__(boardSize)
 
 	def load(self,state):
 		for (r,row) in enumerate(state):
@@ -26,7 +27,7 @@ class SpecGo(core.Go):
 			(r,c,action,color)=d
 			colorKey=(1-color)<<1 # {-1,1}->{1,0}
 			if action!="-" and (r,c) not in res[colorKey]:
-				res[colorKey].append((r,c))
+				res[colorKey].add((r,c))
 			# this is rather sloppy but correct. the time will show if it is effective enough
 			if action!="+" and (r,c) not in res[colorKey] and (r,c) not in res[1-colorKey]:
 				self._helper.clear()
@@ -51,8 +52,8 @@ class SpecGo(core.Go):
 
 
 class Engine:
-	def __init__(self):
-		self._g=SpecGo()
+	def __init__(self,g=None):
+		self._g=g or SpecGo()
 		self._moveList=(set(),set())
 
 	def load(self,state1,diff):
@@ -61,20 +62,35 @@ class Engine:
 
 	def iterativelyDeepen(self,state2):
 		for i in range(1,10):
-			seq=self.dfs(state2,i)
-			if seq: return seq
+			for color in [BLACK,WHITE]:
+				self._g.toMove=color
+				seq=self.dfs(state2,i)
+				if seq:
+					seq.reverse()
+					return seq
 
 	def dfs(self,state2,limit):
 		g=self._g
-		for (r,c) in self._moveList[g.toMove]:
+		for (r,c) in self._moveList[(g.toMove-1)>>1]:
+			if g.board[r][c]!=EMPTY: continue
+			neighbours=(
+				g.board[r-1][c] if r>0 else None,
+				g.board[r+1][c] if r<g.boardSize else None,
+				g.board[r][c-1] if c>0 else None,
+				g.board[r][c+1] if c<g.boardSize else None
+			)
 			g.doMove(g.toMove,r,c)
-			if g.board==state2: return [(r,c)]
+			captured=tuple(
+				coords for (i,coords) in enumerate(((r-1,c),(r+1,c),(r,c-1),(r,c+1)))
+				if neighbours[i] is not None and neighbours[i]!=EMPTY and g.board[coords[0]][coords[1]]==EMPTY
+			)
+			if g.hash()==state2.hash(): return [(-1*g.toMove,r,c)]
 			if limit>1:
 				seq=self.dfs(state2,limit-1)
 				if seq:
-					seq.append((r,c))
+					seq.append((-1*g.toMove,r,c))
 					return seq
-			g.undoMove(m)
+			g.undoMove(r,c,captured)
 		return False
 
 eng=Engine()