anchor.diff:  	    Bin;
   	  throw:{badarg,Warning} ->
   	    add_warning(Bin, Warning),
  -	    #c_call{module=#c_literal{val=erlang},
  +	    #c_call{anno=Anno,
  +		    module=#c_literal{val=erlang},
   		    name=#c_literal{val=error},
   		    args=[#c_literal{val=badarg}]}
       end.
  
positive.code: %% We inline some very common higher order list operations.
  %% We use the same evaluation order as the library function.
  
  call_1(_Call, lists, all, [Arg1,Arg2], Sub) ->
      Loop = #c_var{name={'lists^all',1}},
      F = #c_var{name='F'},
      Xs = #c_var{name='Xs'},
      X = #c_var{name='X'},
      Err1 = #c_tuple{es=[#c_literal{val='case_clause'}, X]},
      CC1 = #c_clause{pats=[#c_literal{val=true}], guard=#c_literal{val=true},
  		    body=#c_apply{op=Loop, args=[Xs]}},
      CC2 = #c_clause{pats=[#c_literal{val=false}], guard=#c_literal{val=true},
  		    body=#c_literal{val=false}},
      CC3 = #c_clause{pats=[X], guard=#c_literal{val=true},
  		    body=#c_primop{name=#c_literal{val='match_fail'},
  				   args=[Err1]}},
      C1 = #c_clause{pats=[#c_cons{hd=X, tl=Xs}], guard=#c_literal{val=true},
  		   body=#c_case{arg=#c_apply{op=F, args=[X]},
  				clauses = [CC1, CC2, CC3]}},
      C2 = #c_clause{pats=[#c_literal{val=[]}], guard=#c_literal{val=true},
  		   body=#c_literal{val=true}},
      Err2 = #c_tuple{es=[#c_literal{val='function_clause'}, Xs]},
      C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
  		   body=#c_primop{name=#c_literal{val='match_fail'},
  				  args=[Err2]}},
      Fun = #c_fun{vars=[Xs],
  		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
      L = #c_var{name='L'},
      expr(#c_let{vars=[F, L], arg=#c_values{es=[Arg1, Arg2]},
  		body=#c_letrec{defs=[{Loop,Fun}],
  			       body=#c_apply{op=Loop, args=[L]}}},
  	 Sub);
  call_1(_Call, lists, any, [Arg1,Arg2], Sub) ->
      Loop = #c_var{name={'lists^any',1}},
      F = #c_var{name='F'},
      Xs = #c_var{name='Xs'},
  
negative.code: %%% 		   body=#c_values{es=[#c_literal{val=[]}, A]}},
      Err = #c_tuple{es=[#c_literal{val='function_clause'}, Xs]},
      C3 = #c_clause{pats=[Xs], guard=#c_literal{val=true},
  		   body=match_fail(Anno, Err)},
      Fun = #c_fun{vars=[Xs, Avar],
  		 body=#c_case{arg=Xs, clauses=[C1, C2, C3]}},
      L = #c_var{name='L'},
      expr(#c_let{vars=[F, Avar, L], arg=#c_values{es=[Arg1, Arg2, Arg3]},
  		body=#c_letrec{defs=[{Loop,Fun}],
  %%% Tuple passing version
  			       body=#c_apply{anno=Anno,
  					     op=Loop,
  					     args=[L, Avar]}}},
  %%% Multiple-value version
  %%% 			       body=#c_let{vars=[Xs, A],
  %%% 					   arg=#c_apply{op=Loop,
  