anchor.diff:    {primop, fun erlang:'>='/2, [A, B]}.
   plus(A, B) ->
     {primop, fun (X, Y) -> 
  -%%	       io:format("~p + ~p = ~p~n", [X,Y,X+Y]), 
   	       X + Y end, [A,B]}.
   times(A, B) ->
     {primop, fun (X, Y) -> 
  -%%	       io:format("~p * ~p = ~p~n", [X,Y,X*Y]), 
   	       X * Y end, [A, B]}.
   minus(A, B) ->
     {primop, fun erlang:'-'/2, [A, B]}.
  
positive.code: 	    times({'@', "N1", {t, [{SpaceD, minus({'#', SpaceD}, 1)}]}}, 2)}}]},
  	[{TimeD, 10},
  	 {SpaceD, 10}]},
    %% Parallel, multi-dimensional (tournament) wheredim clause (introducing parallelism)
    E6 = {wheredim,
    	{wherevar, "A", 
    	 [{"A",
  
negative.code: 		       lte({'#', SpaceD}, 1024)),
  	    {'#', SpaceD},
  	    1}}]},
    	[{TimeD, 14},
    	 {SpaceD, 0}]},
  
    %% Parallel, two-dimensional (tournament)
    E7 = {wheredim,
  	{wherevar, {'@', "Y1", {t, [{XD, 0}]}},
  	 [{"Y1",
  	   {'if', lte({'#', TimeD}, 0),
  	    "X1",
  	    {'@',
  	     plus(
  	       plus(
  		 {'@', "Y1", {t, [{XD, times({'#', XD}, 2)},
  				  {YD, times({'#', YD}, 2)}]}},
  		 {'@', "Y1", {t, [{XD, plus(times({'#', XD}, 2), 1)},
  				  {YD, times({'#', YD}, 2)}]}}
  		),
  	       plus(
  		 {'@', "Y1", {t, [{XD, times({'#', XD}, 2)}, 
  				  {YD, plus(times({'#', YD}, 2), 1)}]}},
  		 {'@', "Y1", {t, [{XD, plus(times({'#', XD}, 2), 1)}, 
  				  {YD, plus(times({'#', YD}, 2), 1)}]}}
  		)
  	      ),
  	     {t, [{TimeD, minus({'#', TimeD}, 1)}]}}}},
  	  {"X1",
  	   {'if', tand(tand(gte({'#', XD}, 1), lte({'#', YD}, 1024)),
  		       tand(gte({'#', YD}, 1), lte({'#', YD}, 1024))),
  	    {'#', XD},
  	    1}}]},
  	[{TimeD, 8},
  	 {XD, 0},
  	 {YD, 0}]},
  
    %% Parallel, multi-dimensional matrix multiplication (the one youre all waiting for ;))
  
    ?assertMatch({0,_}, run_test(E1, [], [], [], [TimeD], 0)),
    ?assertMatch({[{[0], time}, {[1], space}],_}, run_test(E2, [], [], [], [], 0)),
    ?assertMatch({[{[0], time}, {[1], space}],_}, run_test(E3, [], [], [], [], 0)),
    ?assertMatch({5,_}, run_test(E4, [], [], [], [TimeD,SpaceD], 0)),
    ?assertMatch({540160,_}, run_test(E6, [], [], [], [TimeD,SpaceD], 0)),
    ?assertMatch({8323711,_}, run_test(E7, [], [], [], [TimeD, SpaceD], 0)).
  
  run_test(Src) ->
    I = fun (X) -> X end,
  