anchor.diff:  	t_update_map_expressions,
   	t_update_assoc, t_update_assoc_large,
           t_update_exact, t_update_exact_large,
  -	t_guard_bifs, t_guard_sequence, t_guard_update,
  -	t_guard_receive,t_guard_fun, t_list_comprehension,
  +	t_guard_bifs,
  +        t_guard_sequence, t_guard_sequence_large,
  +        t_guard_update, t_guard_update_large,
  +	t_guard_receive, t_guard_receive_large,
  +        t_guard_fun, t_list_comprehension,
   	t_map_equal, t_map_compare,
   	t_map_sort_literals,
   
  
positive.code: build_and_check(N, M0, F, Ks) ->
      K  = build_key(F,N),
      M1 = maps:put(K,K,M0),
      ok = check_keys_exist([K|Ks], M1),
      M2 = maps:update(K,v,M1),
      v  = maps:get(K,M2),
      build_and_check(N-1,M1,F,[K|Ks]).
  
  remove_and_check([],_) -> ok;
  remove_and_check([K|Ks], M0) ->
      K     = maps:get(K,M0),
      true  = maps:is_key(K,M0),
      M1    = maps:remove(K,M0),
      false = maps:is_key(K,M1),
      true  = maps:is_key(K,M0),
      ok    = check_keys_exist(Ks,M1),
      error = maps:find(K,M1),
      remove_and_check(Ks, M1).
  
  
negative.code:     %% cleanup
      done = call(Pid, done),
      ok.
  
  -define(t_guard_receive_large_procs, 1500).
  
  t_guard_receive_large(Config) when is_list(Config) ->
      M = lists:foldl(fun(_,#{procs := Ps } = M) ->
                              M#{ procs := Ps#{ spawn_link(fun() -> grecv_loop() end) => 0 }}
                      end, #{procs => #{}, done => 0}, lists:seq(1,?t_guard_receive_large_procs)),
      lists:foreach(fun(Pid) ->
                            Pid ! {self(), hello}
                    end, maps:keys(maps:get(procs,M))),
      ok = guard_receive_large_loop(M),
      ok.
  
  guard_receive_large_loop(#{done := ?t_guard_receive_large_procs}) ->
      ok;
  guard_receive_large_loop(M) ->
      receive
          #{pid := Pid, msg := hello} ->
              case M of
                  #{done := Count, procs := #{Pid := 150}} ->
                      Pid ! {self(), done},
                      guard_receive_large_loop(M#{done := Count + 1});
                  #{procs := #{Pid := Count} = Ps} ->
                      Pid ! {self(), hello},
                      guard_receive_large_loop(M#{procs := Ps#{Pid := Count + 1}})
              end
      end.
  
  grecv_loop() ->
      receive
          {_, done} ->
              ok;
          {Pid, hello} ->
              Pid ! #{pid=>self(), msg=>hello},
              grecv_loop()
      end.
  
  call(Pid, M) ->
      Pid ! {self(), M}, receive {Pid, Res} -> Res end.
  