anchor.diff:  
   -spec exec_prepared_statement(atom(), [], any()) -> {{ok, integer()} | {error, any()}, state()}.
   exec_prepared_statement(Name, Args, #state{cn=Cn, statements=Statements}=State) ->
  -    {_Columns, Stmt} = dict:fetch(Name, Statements),
  +    PrepStmt = dict:fetch(Name, Statements),
  +    Stmt = PrepStmt#prepared_statement.stmt,
       NArgs = input_transforms(Args, State),
  -    ok = pgsql:bind(Cn, Stmt, NArgs),
  +    ok = pgsql:bind(Cn, PrepStmt#prepared_statement.stmt, NArgs),
       %% Note: we might get partial results here for big selects!
       Rv =
           try 
  
positive.code: load_statements(Connection, [{Name, SQL}|T], Dict) when is_atom(Name) ->
      case pgsql:parse(Connection, atom_to_list(Name), SQL, []) of
          {ok, Statement} ->
              {ok, {statement, _Name, Desc, _DataTypes}} = pgsql:describe(Connection, Statement),
              Columns = [ ColName || {_,ColName, _, _, _,_} <- Desc],
              load_statements(Connection, T, dict:store(Name, {Columns, Statement}, Dict));
          {error, {error, error, _ErrorCode, Msg, Position}} ->
              {error, {syntax, {Msg, Position}}};
          Error ->
  
negative.code:          exec_prepared_statement/3,
           exec_prepared_select/3]).
  
  -record(state, 
          {cn,
           statements = dict:new() :: dict(),
           ctrans :: dict() | undefined }).
  
  -record(prepared_statement, 
          {name :: string(),
           input_types  :: any(),
           output_fields :: any(),
           stmt :: any() } ).
  
  -type connection() :: pid().
  -type state() :: any().
  