anchor.diff:  			{reply, {error, not_found}, State}
   	end.
   
  +-spec handle_cast(Request :: term(), State :: term()) -> Result when
  +	Result :: {noreply, NewState}
  +			| {noreply, NewState, Timeout}
  +			| {noreply, NewState, hibernate}
  +			| {stop, Reason :: term(), NewState},
  +	NewState :: term(),
  +	Timeout :: non_neg_integer() | infinity.
   handle_cast({remove_game, GameId}, _From, State) ->
   	GameDict = State#state.games,
   	{noreply, State#state{games = dict:erase(GameId, GameDict)}}.
   
  +-spec handle_info(Info :: timeout | term(), State :: term()) -> Result when
  +	Result :: {noreply, NewState}
  +			| {noreply, NewState, Timeout}
  +			| {noreply, NewState, hibernate}
  +			| {stop, Reason :: term(), NewState},
  +	NewState :: term(),
  +	Timeout :: non_neg_integer() | infinity.
   handle_info({'DOWN', Ref, process, _Pid, _Reason}, 
   				#state{games = GameDict} = State) ->
   	Games = dict:to_list(GameDict),
  
positive.code: 		{error, Reason} ->
  			{reply, {error, Reason}, State}
  	end;
  
  handle_call({get_game, GameId}, _From, State) ->
  	GameDict = State#state.games,
  	case dict:find(GameId, GameDict) of
  
negative.code: %% Gen_server callbacks
  %%====================================================================
  
  -spec init(Args :: term()) -> Result when
  	Result :: {ok, State}
  			| {ok, State, Timeout}
  			| {ok, State, hibernate}
  			| {stop, Reason :: term()}
  			| ignore,
  	State :: term(),
  	Timeout :: non_neg_integer() | infinity.
  init([]) ->
  	BcManagerSup = whereis(bc_manager_sup),
  	{ok, #state{manager_sup = BcManagerSup, games = dict:new()}}.
  
  -spec handle_call(Request :: term(), From :: {pid(), Tag :: term()}, State :: term()) -> Result when
  	Result :: {reply, Reply, NewState}
  			| {reply, Reply, NewState, Timeout}
  			| {reply, Reply, NewState, hibernate}
  			| {noreply, NewState}
  			| {noreply, NewState, Timeout}
  			| {noreply, NewState, hibernate}
  			| {stop, Reason, Reply, NewState}
  			| {stop, Reason, NewState},
  	Reply :: term(),
  	NewState :: term(),
  	Timeout :: non_neg_integer() | infinity,
  	Reason :: term().
  handle_call({create_game, Privacy}, _From, 
  	#state{manager_sup = BcManagerSup, games = GameDict} = State) ->
  	case bc_game_model:save(Privacy, ?PENDING) of
  		{ok, GameId} ->
  			{ok, BcGameSup} = supervisor:start_child(BcManagerSup, #{
  				id => GameId,
  				start => {bc_game_sup, start_link, []},
  				type => supervisor,
  				restart => transient,
  				shutdown => 5000,
  				modules => [bc_game_sup]
  			}),
  			{ok, GameEventPid} = supervisor:start_child(BcGameSup, #{
  				id => bc_game_event,
  				start => {gen_event, start_link, []},
  				restart => transient,
  				shutdown => brutal_kill,
  				modules => [gen_event]
  			}),
  			{ok, BcGameFsm} = supervisor:start_child(BcGameSup, #{
  				id => bc_game_fsm,
  				start => {bc_game_fsm, start_link, [GameId, GameEventPid, BcGameSup]},
  				restart => transient,
  				shutdown => 10000,
  				modules => [bc_game_fsm]
  			}),
  			Ref = erlang:monitor(process, BcGameFsm),
  			BcGame = bc_game:create(GameId, GameEventPid, BcGameFsm),
  