namespace std __attribute__ ((__visibility__ ("default")))
{
  template < typename _Alloc > class allocator;
  template < class _CharT > struct char_traits;
  template < typename _CharT, typename _Traits =
    char_traits < _CharT >, typename _Alloc =
    allocator < _CharT > >class basic_string;
  typedef basic_string < char >string;
}
typedef long unsigned int size_t;
namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
{
  template < typename _Tp > class new_allocator
  {
  };
}
namespace std __attribute__ ((__visibility__ ("default")))
{
template < typename _Tp > class allocator:public __gnu_cxx::new_allocator <
    _Tp >
  {
  public:typedef size_t size_type;
    template < typename _Tp1 > struct rebind
    {
      typedef allocator < _Tp1 > other;
    };
  };
  template < typename _CharT, typename _Traits,
    typename _Alloc > class basic_string
  {
    typedef typename _Alloc::template rebind <
      _CharT >::other _CharT_alloc_type;
    typedef typename _CharT_alloc_type::size_type size_type;
  private:struct _Rep_base
    {
    };
    struct _Rep:_Rep_base
    {
      _CharT *_M_refdata () throw ()
      {
      }
    };
    struct _Alloc_hider:_Alloc
    {
      _Alloc_hider (_CharT * __dat, const _Alloc & __a):_Alloc (__a),
	_M_p (__dat)
      {
      }
      _CharT *_M_p;
    };
  private:mutable _Alloc_hider _M_dataplus;
    static _Rep & _S_empty_rep ()
    {
    }
  public:inline basic_string ();
    size_type length () const
    {
    }
    const _CharT *data () const
    {
    }
  };
template < typename _CharT, typename _Traits, typename _Alloc > inline basic_string < _CharT, _Traits, _Alloc >::basic_string ():_M_dataplus (_S_empty_rep ()._M_refdata (),
	       _Alloc
	       ())
  {
  }
  template < typename _CharT, typename _Traits,
    typename _Alloc > inline bool operator== (const basic_string < _CharT,
					      _Traits, _Alloc > &__lhs,
					      const _CharT * __rhs)
  {
  }
}
namespace sigslot
{
  class single_threaded
  {
  };
  template < class mt_policy = single_threaded > class has_slots:public
    mt_policy
  {
  };
};
namespace buzz
{
  class XmlConstants
  {
  public:static const std::string & str_empty ();
  };
  class Jid
  {
  public:explicit Jid ();
    const std::string & node () const
    {
      return !data_ ? XmlConstants::str_empty () : data_->node_name_;
    }
    class Data
    {
    public:Data ():refcount_ (1)
      {
      }
      const std::string node_name_;
    private:int refcount_;
    };
    Data *data_;
  };
  template < typename T > class scoped_ptr
  {
  private:T * ptr;
  public:typedef T element_type;
  explicit scoped_ptr (T * p = 0):ptr (p)
    {
    }
    T *operator-> () const
    {
    }
    T *get () const
    {
    }
  };
}
namespace buzz
{
  class SaslHandler;
  enum XmppReturnStatus
  {
  };
  class XmppOutputHandler
  {
  };
  class XmppSessionHandler
  {
  };
  class XmppEngine
  {
  public:static XmppEngine *Create ();
    enum Error
    {
      ERROR_NONE =
	0, ERROR_XML, ERROR_STREAM, ERROR_VERSION, ERROR_UNAUTHORIZED,
    };
    virtual const Jid & GetUser () = 0;
    virtual XmppReturnStatus SetSaslHandler (SaslHandler * h) = 0;
  };
  class AsyncSocket
  {
  };
  class XmppPassword
  {
  };
  class FormatXmppPassword
  {
  public:FormatXmppPassword ()
    {
    }
    void Append (const std::string & text)
    {
      Append (text.data (), text.length ());
    }
    void Append (const char *data, size_t length)
    {
      EnsureStorage (length_ + length + 1);
    }
    void EnsureStorage (size_t n)
    {
      size_t old_capacity = capacity_;
      char *old_storage = storage_;
      for (;;)
	{
	  capacity_ *= 2;
	    break;
	}
      storage_ = new char[capacity_];
	{
	  for (size_t i = 1; i < old_capacity; i++)
	    {
	      old_storage[i] = old_storage[i - 1];
	    }
	}
    }
    ~FormatXmppPassword ()
    {
	{
	  for (size_t i = 1; i < capacity_; i++)
	    {
	    }
	}
    }
  private:char *storage_;
    size_t capacity_;
    size_t length_;
  };
  class Task
  {
  };
  class XmppClient:public Task, public sigslot::has_slots <>
  {
    virtual int ProcessStart ();
    class Private;
      scoped_ptr < Private > d_;
  };
  class SaslMechanism
  {
  };
  class SaslPlainMechanism:public SaslMechanism
  {
  public:SaslPlainMechanism (const buzz::Jid user_jid,
			const XmppPassword & password):user_jid_ (user_jid),
      password_ (password)
    {
      FormatXmppPassword credential;
        credential.Append (user_jid_.node ());
    }
  private:  Jid user_jid_;
    XmppPassword password_;
  };
  class SaslHandler
  {
  };
  class PreXmppAuth:public SaslHandler
  {
  };
  class PlainSaslHandler:public SaslHandler
  {
  public:PlainSaslHandler (const Jid & jid,
		      const XmppPassword & password):jid_ (jid),
      password_ (password)
    {
    }
    virtual SaslMechanism *CreateSaslMechanism (const std::string & mechanism)
    {
	{
	  return new SaslPlainMechanism (jid_, password_);
	}
    }
  private:Jid jid_;
    XmppPassword password_;
  };
  class XmppClient::Private:public sigslot::has_slots <>,
    public XmppSessionHandler, public XmppOutputHandler
  {
  public:Private (XmppClient * client):client_ (client), socket_ (__null),
      pre_engine_error_ (XmppEngine::ERROR_NONE), signal_closed_ (false)
    {
    }
    XmppClient *const client_;
    scoped_ptr < AsyncSocket > socket_;
    scoped_ptr < XmppEngine > engine_;
    XmppPassword pass_;
    XmppEngine::Error pre_engine_error_;
    bool signal_closed_;
  };
  int XmppClient::ProcessStart ()
  {
      {
	d_->engine_->
	  SetSaslHandler (new
			  PlainSaslHandler (d_->engine_->GetUser (),
					    d_->pass_));
      }
  }
}