anchor.diff:  
   same_time_yielding_with_cancel_test(Other, Accessor) ->
       Mem = mem(),
  -    SchdlrsOnln = erlang:system_info(schedulers_online),
  +    SchdlrsOnline = erlang:system_info(schedulers_online),
  +    SchdlrsToUse = erlang:max(1, erlang:min(8, SchdlrsOnline) - 1),
  +    NrOfTimeouts = (?TIMEOUT_YIELD_LIMIT*3+1) * SchdlrsToUse,
  +    NrOfTimeoutsPerScheduler = NrOfTimeouts div SchdlrsToUse,
       Tmo = erlang:monotonic_time(millisecond) + 6000,
       Tester = self(),
       Cancelor = case Other of
  
positive.code:                true -> [{accessor, Cancelor}, {abs, true}]
             end,
      Tmrs = lists:map(fun (I) ->
                               process_flag(scheduler, (I rem SchdlrsOnln) + 1),
                               erlang:start_timer(Tmo, self(), hej, Opts)
                       end,
                       lists:seq(1, (?TIMEOUT_YIELD_LIMIT*3+1)*SchdlrsOnln)),
      true = mem_larger_than(Mem),
      case Other of
          false ->
  
negative.code: same_time_yielding(Config) when is_list(Config) ->
      Mem = mem(),
      Ref = make_ref(),
      SchdlrsOnline = erlang:system_info(schedulers_online),
      SchdlrsToUse = erlang:max(1, erlang:min(8, SchdlrsOnline) - 1),
      StartTime = erlang:monotonic_time(millisecond),
      Tmo = StartTime + 20000,
      NrOfTimeouts = (?TIMEOUT_YIELD_LIMIT*3+1) * SchdlrsToUse,
      NrOfTimeoutsPerScheduler = NrOfTimeouts div SchdlrsToUse,
      Tmrs = lists:map(fun (I) ->
                               SchedulerId =
                                   case SchdlrsOnline of
                                       1 -> 1;
                                       _ ->
                                           ((I div NrOfTimeoutsPerScheduler) rem SchdlrsToUse)  + 2
                                   end,
                               process_flag(scheduler, SchedulerId),
                               erlang:start_timer(Tmo, self(), Ref, [{abs, true}]),
                               SchedulerId
                       end,
                       lists:seq(1, NrOfTimeouts)),
      process_flag(scheduler, 1),
      AllTimersStartedTime = erlang:monotonic_time(millisecond),
      true = mem_larger_than(Mem),
      {TimeToReceive, TimeUntilFirst} = receive_all_timeouts(length(Tmrs), Ref),
      Done = erlang:monotonic_time(millisecond),
      true = Done >= Tmo,
      MsAfterTmo = Done - Tmo,
      io:format("Done ~p ms after Tmo\nInfo: ~p\n",
                [MsAfterTmo,
                 {'TimeToStartAllTimers', AllTimersStartedTime - StartTime,
                  'TimeInReceiveUntilFirst',TimeUntilFirst,
                  'TimeToReceive', TimeToReceive}]),
      case erlang:system_info(build_type) of
          opt ->
              true = MsAfterTmo < 200;
  