anchor.diff:              {L, false, State}
       end.
   
  -recv_tasks([], TaskSizeLookup, State, _) ->
  -    State#state{task_size_lookup = TaskSizeLookup};
  +recv_tasks([], Done, State, _) ->
  +    if
  +        Done == false ->
  +            self() ! task;
  +        true ->
  +            ok
  +    end,
  +    State;
   
   recv_tasks([{TaskSize, Iterations, Step, Index, Pid, Timeout, TransId} | L],
  -           TaskSizeLookup,
  +           Done,
              #state{tasks_failed = Failed,
  -                  target_time = TargetTime} = State, Dispatcher) ->
  +                  target_time = TargetTime,
  +                  task_size_lookup = TaskSizeLookup} = State, Dispatcher) ->
   
       case cloudi_job:recv_async(Dispatcher, Timeout, TransId) of
           {ok, Response} ->
               <<ElapsedTime:32/float-native, PiResult/binary>> = Response,
               send_results(Index, PiResult, Pid, State, Dispatcher),
  -            recv_tasks(L, cloudi_task_size:put(TaskSize,
  -                                               TargetTime,
  -                                               ElapsedTime,
  -                                               Pid,
  -                                               TaskSizeLookup),
  -                       State, Dispatcher);
  +            NewTaskSizeLookup = cloudi_task_size:put(TaskSize,
  +                                                     TargetTime,
  +                                                     ElapsedTime,
  +                                                     Pid,
  +                                                     TaskSizeLookup),
  +            NextState = State#state{task_size_lookup = NewTaskSizeLookup},
  +            if
  +                Done == false ->
  +                    {Task, NewDone, FinalState} = send_tasks(1, [], NextState,
  +                                                             Dispatcher),
  +                    recv_tasks(L ++ Task, NewDone, FinalState, Dispatcher);
  +                true ->
  +                    recv_tasks(L, Done, NextState, Dispatcher)
  +            end;
           {error, timeout} ->
               ?LOG_ERROR("index ~p result timeout (after ~p ms)~n",
                          [Index, Timeout]),
  
positive.code:                          step = Step,
                           index = Index,
                           timeout = Timeout * 2},
              recv_tasks(L, cloudi_task_size:put(TaskSize,
                                                 TargetTime,
                                                 ElapsedTime,
                                                 Pid,
                                                 TaskSizeLookup),
                         State#state{tasks_failed = [Task | Failed]},
                         Dispatcher);
          {error, Reason} ->
              ?LOG_ERROR("recv_async error ~p~n", [Reason]),
              recv_tasks(L, TaskSizeLookup, State, Dispatcher)
      end.
  
  send_results(DigitIndex, PiResult, Pid,
  
negative.code:     {noreply, setup(State, Dispatcher)};
  
  cloudi_job_handle_info(task,
                         #state{concurrent_tasks = ConcurrentTasks} = State,
                         Dispatcher) ->
      {Requests, Done, NewState} = send_tasks(ConcurrentTasks, [],
                                              State, Dispatcher),
      {noreply, recv_tasks(Requests, Done, NewState, Dispatcher)};
  
  cloudi_job_handle_info(Request, State, _) ->
      ?LOG_WARN("Unknown info \"~p\"", [Request]),
  