anchor.diff:  		    DoReport(fail, Reason),
   		    {failure, Fun, Input, IDom, 
   		     QCT#triq{count=Count+1,result={'EXIT', Reason}}}
  -	    end;
  -	
  -	{'prop:forall', Dom2, Syntax2, Fun2, Body2} ->
  -	    check_forall(0, Dom2, Fun2, Syntax2, QCT#triq{body=Body2}, gb_sets:new());
  -
  -	Any ->
  -	    DoReport(fail,Any),
  -	    {failure, Fun, Input, IDom, QCT#triq{count=Count+1,result=Any}}
  -
  -    catch
  -	Class : Exception ->
  -	    DoReport(fail, {Class, Exception, erlang:get_stacktrace()}),
  -	    {failure, Fun, Input, IDom, QCT#triq{count=Count+1,result={'EXIT',Exception}}}
  -	
  -    end.
  -    
  +    end,
  +
  +    Yield.
   
   check_forall(GS,_,_,_,#triq{size=GS,count=Count}, _) ->
       {success, Count};
  -
  -%check_forall(_,_,_,_,#triq{size=Count,count=Count}, _) ->
  -%    {success, Count};
   
   check_forall(N,Dom,Fun,Syntax,#triq{size=GS, context=Context}=QCT, Tested) ->
       Input = generate(Dom, 20 + 4*N),
  
positive.code: 	    Main = self(),
  	    PID = spawn_link
  		    (fun() ->
  			     Result = check(fun(none)->Fun2()end,none,none,QCT#triq{body=Body2}),
  			     Main ! {self(), Result}
  		     end),
  	    receive 
  		{PID, Result} -> 
  
  		    unlink(PID),
  		    receive
  			{'EXIT', PID, _} ->
  			    true
  		    after 0 ->
  			    true
  		    end,
  		    process_flag(trap_exit, WasTrap),
  		    Result;
  
  		{'EXIT', PID, Reason} ->
  		    process_flag(trap_exit, WasTrap),
  		    DoReport(fail, Reason),
  		    {failure, Fun, Input, IDom, QCT#triq{count=Count+1,result={'EXIT', Reason}}}
  		    
  	    end;
  	
  	{'prop:timeout', Limit, Fun2, Body2} ->
  
  	    Main = self(),
  	    Controller = spawn
  	        (fun() -> 
  			 process_flag(trap_exit, true),
  			 Controller = self(),
  			 
  			 Slave = spawn_link
  				 (fun() ->
  					  Slave = self(),
  					  Result = check(fun(none)->Fun2()end,
  							 none,
  							 none,
  							 QCT#triq{body=Body2}),
  					  Controller ! {Slave, Result}
  				  end),
  			 
  			 receive 
  			     {Slave, Result} ->
  				 % io:format("~p: result=~p~n", [Controller,Result]),
  				 Main ! {Controller, Result };
  
  			     {'EXIT', Slave, Reason} ->
  				 % io:format("~p: died=~p~n", [Controller,Reason]),
  				 DoReport(fail, Reason),
  				 Main ! {Controller, {failure, Fun, Input, IDom, 
  				  QCT#triq{count=Count+1,result={'EXIT', Reason}}}};
  			     
  			     {'EXIT', _, timeout} ->
  				 erlang:exit(Slave,kill)			     
  			 end
  		 end),
  
  	    receive 
  		{Controller, Result} ->
  		    Result;
  
  		Bogus ->
  		    io:format("wrong: ~p [expected ~p]~n", [Bogus, Controller]),
  		    erlang:throw({badmsg, Bogus})
  		    
  	    after Limit ->
  
  		    % Yank the controller (and the slave)
  		    erlang:exit(Controller, timeout),
  
  		    % flush any reply from our queue
  		    receive {Controller, _} -> ignore
  		    after 5 -> ignore end,
  		    
  
negative.code: report(fail,Value) ->
      io:format("Failed with: ~p~n", [Value]).
  
  check(Fun,Input,IDom,#triq{count=Count,report=DoReport}=QCT) ->
  
      try Fun(Input) of	
  