anchor.diff:  		    {error,Cs};
   		false ->
   		    %% If possible, expand this variable to a previously
  -		    %% matched term.
  +		    %% constructed tuple
   		    E = case_expand_var(E0, Sub),
   		    case_opt_arg_1(E, Cs, LitExpr)
   	    end
  
positive.code:                     %% with exported variables, but the return value is
                      %% ignored). We can remove the first variable and the
                      %% the first value returned from the 'let' argument.
                      Arg2 = remove_first_value(Arg1, Sub),
                      Let1 = Let0#c_let{vars=Vars,arg=Arg2,body=Body},
                      post_opt_let(Let1, Sub);
                  true ->
  
negative.code:     opt_build_stacktrace(Let1).
  
  
  %% remove_first_value(Core0) -> Core.
  %%  Core0 is an expression that returns at least two values.
  %%  Remove the first value returned from Core0.
  
  remove_first_value(#c_values{es=[V|Vs]}) ->
      Values = core_lib:make_values(Vs),
      case is_safe_simple(V) of
          false ->
              #c_seq{arg=V,body=Values};
          true ->
              Values
      end;
  remove_first_value(#c_case{clauses=Cs0}=Core) ->
      Cs = remove_first_value_cs(Cs0),
      Core#c_case{clauses=Cs};
  remove_first_value(#c_receive{clauses=Cs0,action=Act0}=Core) ->
      Cs = remove_first_value_cs(Cs0),
      Act = remove_first_value(Act0),
      Core#c_receive{clauses=Cs,action=Act};
  remove_first_value(#c_let{body=B}=Core) ->
      Core#c_let{body=remove_first_value(B)};
  remove_first_value(#c_seq{body=B}=Core) ->
      Core#c_seq{body=remove_first_value(B)};
  remove_first_value(#c_primop{}=Core) ->
      Core;
  remove_first_value(#c_call{}=Core) ->
      Core.
  
  remove_first_value_cs(Cs) ->
      [C#c_clause{body=remove_first_value(B)} ||
          #c_clause{body=B}=C <- Cs].
  
  %% maybe_suppress_warnings(Arg, #c_var{}, PreviousBody) -> Arg'
  