anchor.diff:  	  stk=clear_dead_stk(Sr#sr.stk, Until, Vdb)}.
   
   clear_dead_reg(Sr, Until, Vdb) ->
  -    Reg = map(fun ({_I,V} = IV) ->
  -		      case vdb_find(V, Vdb) of
  -			  {V,_,L} when L > Until -> IV;
  -			  _ -> free		%Remove anything else
  -		      end;
  -		  ({reserved,_I,_V} = Reserved) -> Reserved;
  -		  (free) -> free
  -	      end, Sr#sr.reg),
  +    Reg = [case R of
  +            {_I,V} = IV ->
  +                case vdb_find(V, Vdb) of
  +                    {V,_,L} when L > Until -> IV;
  +                    _ -> free		%Remove anything else
  +                end;
  +            {reserved,_I,_V} = Reserved -> Reserved;
  +            free -> free
  +        end || R <- Sr#sr.reg],
       reserve(Sr#sr.res, Reg, Sr#sr.stk).
   
   clear_dead_stk(Stk, Until, Vdb) ->
  -    map(fun ({V} = T) ->
  -		case vdb_find(V, Vdb) of
  -		    {V,_,L} when L > Until -> T;
  -		    _ -> dead			%Remove anything else
  -		end;
  -	    (free) -> free;
  -	    (dead) -> dead
  -	end, Stk).
  +    [case S of
  +	    {V} = T ->
  +            case vdb_find(V, Vdb) of
  +                {V,_,L} when L > Until -> T;
  +                _ -> dead   %Remove anything else
  +            end;
  +        free -> free;
  +        dead -> dead
  +     end || S <- Stk].
  +
   
   %% sr_merge(Sr1, Sr2) -> Sr.
   %%  Merge two stack/register states keeping the longest of both stack
  
positive.code: -export([module/2]).
  
  -import(lists, [member/2,keymember/3,keysort/2,keydelete/3,
  		append/1,map/2,flatmap/2,filter/2,foldl/3,foldr/3,mapfoldl/3,
  		sort/1,reverse/1,reverse/2]).
  -import(v3_life, [vdb_find/2]).
  
  
negative.code:     [{test,select_type_test(Type),{f,Tf},[R]},
       {test,is_eq_exact,{f,Vf},[R,{Type,Val}]}|Sis];
  select_val_cg(Type, R, Vls0, Tf, Vf, Sis) ->
      Vls1 = [case Value of {f,_Lbl} -> Value; _ -> {Type,Value} end || Value <- Vls0],
      [{test,select_type_test(Type),{f,Tf},[R]}, {select_val,R,{f,Vf},{list,Vls1}}|Sis].
      
  select_type_test(integer) -> is_integer;
  