anchor.diff:  	  end;
   	_ -> {State, t_from_term(cerl:concrete(Tree))}
         end;
  -    module ->
  -      Defs = cerl:module_defs(Tree),
  -      Funs = [Fun || {_Var, Fun} <- Defs],
  -      Vars = [Var || {Var, _Fun} <- Defs],
  -      DefinedVars1 = add_def_list(Vars, DefinedVars),
  -      State1 = state__store_funs(Vars, Funs, State),
  -      FoldFun = fun(Fun, AccState) ->
  -		    {S, _} = traverse(Fun, DefinedVars1,
  -				      state__new_constraint_context(AccState)),
  -		    S
  -		end,
  -      lists:foldl(FoldFun, State1, Funs);
       primop ->
         case cerl:atom_val(cerl:primop_name(Tree)) of
   	match_fail -> throw(error);
  
positive.code: -define(MAX_NOF_CLAUSES, 15).
  
  handle_clauses(Clauses, TopVar, Arg, DefinedVars, State) ->
    handle_clauses(Clauses, TopVar, Arg, none, DefinedVars, State).
  
  handle_clauses([], _, _, Action, DefinedVars, State) when Action =/= none ->
    %% Can happen when a receive has no clauses, see filter_match_fail.
    traverse(Action, DefinedVars, State);
  handle_clauses(Clauses, TopVar, Arg, Action, DefinedVars, State) ->
    SubtrTypeList =
      if length(Clauses) > ?MAX_NOF_CLAUSES -> overflow;
         true -> []
  
negative.code:   Guard = cerl:clause_guard(Clause),
    Body = cerl:clause_body(Clause),
    NewSubtrTypes =
      case SubtrTypes of
        overflow ->
          overflow;
        _ ->
  	ordsets:add_element(get_safe_underapprox(Pats, Guard), SubtrTypes)
      end,
    try
      DefinedVars1 = add_def_from_tree_list(Pats, DefinedVars),
      State1 = state__set_in_match(State0, true),
      {State2, PatVars} = traverse_list(Pats, DefinedVars1, State1),
      S = state__store_conj(Arg, eq, t_product(PatVars), State2),
      State3 =
        case SubtrTypes of
          overflow ->
            S;
          _ ->
            SubtrPatVar = ?mk_fun_var(fun(Map) ->
                                          TmpType = lookup_type(Arg, Map),
                                          t_subtract_list(TmpType, SubtrTypes)
                                      end, [Arg]),
            state__store_conj(Arg, sub, SubtrPatVar, S)
        end,
      State4 = handle_guard(Guard, DefinedVars1, State3),
      {State5, BodyVar} = traverse(Body, DefinedVars1,
  