anchor.diff:      put(sock, Sock),
       put(sluice, Sluice),
       put(proxyPort, ProxyPort),
  -    spawn_link(fun() -> fitter(self()) end),
  -    {ok, empty, #state{0, <<>>, <<>>, []}}.
  +    {ok, empty, #state{}}.
   
  -empty({send, Msg}, State) ->
  -    #state{mll = MLL, body = Body} = State,
  +empty(timeout, State) ->
  +    Sock = get(sock),
  +    ok = gen_tcp:close(Sock),
  +    {stop, 'IDLE', State};
  +empty({send, NewMsg}, State) ->
  +    gen_server:cast(get(sluice), {queue, self()}),
  +    append(State, NewMsg).
   
  -ready({send, Msg}, State) ->
  +ready({send, NewMsg}, State) ->
  +    append(State, NewMsg).
   
  -ready(send, State) ->
  +full({send, NewMsg}, State) ->
  +    #state{msgs = Msgs} = State,
  +    {next_state, full, State#state{msgs = [NewMsg|Msgs]}}.
   
  -full({send, Msg}, State) ->
  -
  -full(send, State) ->
  -
  -state_name(_Event, State) ->
  -    {next_state, state_name, State}.
  -
  -handle_event({send, Msgs}, StateName, State
   handle_event(send, _StateName, State) ->
       #state{mll = MLL, body = Body, msgs = Msgs} = State,
       ProxyPort = get(proxyPort),
  
positive.code:     Parc = <<ProxyPort:16, MLLBytes:32, MLL/binary, Body/binary>>,
      Sock = get(sock),
      gen_tcp:send(Sock, Parc),
      {ok, <<"ok">>} = gen_tcp:recv(Sock, 0),
      Sluice = get(sluice),
      case Msgs of
          [] -> gen_server:cast(Sluice, sent),
          _ -> gen_server:cast(Sluice, {sent, self()})
      end,
      {next_state, empty, State#state{mml = <<>>, body = <<>>}};
  handle_event(_Event, StateName, State) ->
      {next_state, StateName, State}.
  
  
negative.code: code_change(_OldVsn, StateName, State, _Extra) ->
      {ok, StateName, State}.
  
  concat(#state{msgs = []} = State) ->
      {next_state, ready, State};
  concat({Count, MLL, Body, [Msg|More]}) ->
      L = meeqo_msg:encode_length(byte_size(Msg)),
      NewMLL = <<MLL/binary, L/binary>>,
      NewBody = <<Body/binary, Msg/binary>>,
      NewState = {Count+1, NewMLL, NewBody, More},
      Full = {next_state, full, NewState},
      case byte_size(NewMLL) + byte_size(NewBody) of
          X when X >= ?PARC_MAX_MEM -> Full;
          _ -> case (Count + 1) of
              ?PARC_MAX_MSG -> Full;
              _ -> concat(NewState)
          end
      end.
  
  append({Count, MLL, Body, Msgs}, NewMsg) ->
      L = meeqo_msg:encode_length(byte_size(NewMsg)),
      NewMLL = <<MLL/binary, L/binary>>,
      NewBody = <<Body/binary, NewMsg/binary>>,
      NewState = {Count+1, NewMLL, NewBody, Msgs},
      Full = {next_state, full, NewState},
      case byte_size(NewMLL) + byte_size(NewBody) of
          X when X >= ?PARC_MAX_MEM -> Full;
          _ -> case (Count + 1) of
              ?PARC_MAX_MSG -> Full;
              _ -> {next_state, ready, NewState}
          end
      end.
  
  