typedef long unsigned int size_t;
            namespace std __attribute__ ((__visibility__ ("default"))) {
        using ::size_t;
        }
          class QString {
        public: inline QString();
        inline QString(const char *ch) : d(fromAscii_helper(ch)) {
     }
        private: struct Data {
      };
        Data *d;
        static Data *fromAscii_helper(const char *str, int size = -1);
        };
          class QGenericArgument {
        };
          class QObject {
         };
          class QWebPage : public QObject {
        public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const {
      }
        class ExtensionOption {
     };
        };
          extern "C" {
        typedef struct _object {
      }
        PyObject;
        typedef struct {
      }
        PyVarObject;
        typedef struct bufferinfo {
      }
        PyTypeObject;
        typedef struct {
      }
        PyListObject;
        }
          namespace boost{
        __extension__ typedef long long long_long_type;
        }
          namespace mpl_ {
        namespace aux {
     }
        }
          namespace boost {
        namespace mpl {
      using namespace mpl_;
      }
       }
          namespace mpl_ {
        template< bool C_ > struct bool_;
        typedef bool_<false> false_;
        template< bool C_ > struct bool_ {
      static const bool value = C_;
      };
        template< typename T, T N > struct integral_c {
      static const T value = N;
      };
        }
          namespace boost{
        template <class T, T val> struct integral_constant : public mpl::integral_c<T, val> {
      };
        namespace detail {
      template <typename T> struct cv_traits_imp {
    typedef T unqualified_type;
    };
      }
        template< typename T > struct is_reference : ::boost::integral_constant<bool,false> {
      };
        template< typename T > struct remove_cv {
      typedef typename boost::detail::cv_traits_imp<T*>::unqualified_type type;
     };
        namespace python {
      namespace detail {
    typedef char* yes_convertible;
    typedef int* no_convertible;
    template <class Target> struct convertible {
    };
    }
      namespace detail {
    template <class Source, class Target> inline Target* upcast(Source* p, yes_convertible, no_convertible, Target*) {
    }
    }
      }
        }
           extern "C++" {
        namespace std {
      class type_info {
    };
      }
        struct __numeric_limits_base {
      };
        }
          namespace boost {
        template< typename T > struct is_integral : ::boost::integral_constant<bool,false> {
      };
        template< typename T > struct is_float : ::boost::integral_constant<bool,false> {
      };
        namespace type_traits {
      template <bool b1, bool b2, bool b3 = false, bool b4 = false, bool b5 = false, bool b6 = false, bool b7 = false> struct ice_or;
      template <> struct ice_or<false, false, false, false, false, false, false> {
    static const bool value = false;
    };
      }
        namespace detail {
      template< typename T > struct is_arithmetic_impl {
    static const bool value = (::boost::type_traits::ice_or< ::boost::is_integral<T>::value, ::boost::is_float<T>::value >::value) ;
    };
      }
        template< typename T > struct is_arithmetic : ::boost::integral_constant<bool,::boost::detail::is_arithmetic_impl<T>::value> {
      };
        namespace type_traits {
      template <typename T> struct is_mem_fun_pointer_impl {
    static const bool value = false;
    };
      }
        template< typename T > struct is_member_function_pointer : ::boost::integral_constant<bool,::boost::type_traits::is_mem_fun_pointer_impl<typename remove_cv<T>::type>::value> {
      };
        template< typename T > struct is_member_pointer : ::boost::integral_constant<bool,::boost::is_member_function_pointer<T>::value> {
      };
        namespace type_traits {
      template <bool b1, bool b2, bool b3 = true, bool b4 = true, bool b5 = true, bool b6 = true, bool b7 = true> struct ice_and;
      template <bool b1, bool b2, bool b3, bool b4, bool b5, bool b6, bool b7> struct ice_and {
    static const bool value = false;
    };
      template <bool b> struct ice_not {
    static const bool value = true;
    };
      }
        namespace detail {
      template< typename T > struct is_pointer_helper {
    static const bool value = false;
    };
      template< typename T > struct is_pointer_impl {
    static const bool value = (::boost::type_traits::ice_and< ::boost::detail::is_pointer_helper<typename remove_cv<T>::type>::value , ::boost::type_traits::ice_not< ::boost::is_member_pointer<T>::value >::value >::value) ;
    };
      }
        template< typename T > struct is_pointer : ::boost::integral_constant<bool,::boost::detail::is_pointer_impl<T>::value> {
      };
        template<typename T> class unwrap_reference {
      };
        struct na {
      };
        }
          namespace boost {
        namespace mpl {
      template< bool C , typename T1 , typename T2 > struct if_c {
    typedef T2 type;
    };
      template< typename T1 = na , typename T2 = na , typename T3 = na > struct if_ {
    private: typedef if_c< static_cast<bool>(T1::value) , T2 , T3 > almost_type_;
    public: typedef typename almost_type_::type type;
    };
      }
        namespace detail {
      template <typename T> struct is_class_impl {
    };
      }
        namespace detail{
      struct false_result {
    };
      }
        namespace python {
      namespace detail {
    template<class T> class borrowed {
    };
    template<typename T> struct is_borrowed_ptr {
    static const bool value = false;
    };
    }
      template <class T = PyObject> class handle;
      template <class T> inline T* incref(T* p) {
    }
      template <class T> struct null_ok;
      namespace detail {
    template <class T> inline T* manage_ptr(detail::borrowed<null_ok<T> >* p, int) {
    }
    }
      template <class T> class handle {
    };
      template<typename T> class is_handle {
    public: static const bool value = false;
    };
     }
       }
          namespace mpl_ {
        }
          namespace boost {
        namespace mpl {
      template< typename T , typename Base , int at_front = 0 > struct v_item : Base {
    };
      }
        namespace mpl {
      template< typename Dummy = na > struct vector0;
      template< typename T0 > struct vector1 : v_item< T0 , vector0< > > {
    };
      template< typename T0, typename T1 > struct vector2 : v_item< T1 , vector1<T0> > {
    };
      template< typename T0, typename T1, typename T2 > struct vector3 : v_item< T2 , vector2< T0,T1 > > {
    };
      template< typename T0, typename T1, typename T2, typename T3 > struct vector4 : v_item< T3 , vector3< T0,T1,T2 > > {
    };
      template< typename T0, typename T1, typename T2, typename T3, typename T4 > struct vector5 : v_item< T4 , vector4< T0,T1,T2,T3 > > {
    };
      template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5 > struct vector6 : v_item< T5 , vector5< T0,T1,T2,T3,T4 > > {
    };
      template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6 > struct vector7 : v_item< T6 , vector6< T0,T1,T2,T3,T4,T5 > > {
    };
      template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7 > struct vector8 : v_item< T7 , vector7< T0,T1,T2,T3,T4,T5,T6 > > {
    };
      template< typename T0, typename T1, typename T2, typename T3, typename T4 , typename T5, typename T6, typename T7, typename T8 > struct vector9 : v_item< T8 , vector8< T0,T1,T2,T3,T4,T5,T6,T7 > > {
    };
      }
        namespace noncopyable_ {
      class noncopyable {
    };
      }
        typedef noncopyable_::noncopyable noncopyable;
        namespace detail {
      template <typename T> class empty_base {
    };
      }
        template <class T, class U, class B = ::boost::detail::empty_base<T> > struct less_than_comparable2 : B {
      };
        template <class T, class U, class B = ::boost::detail::empty_base<T> > struct equality_comparable2 : B {
      };
        template <class T, class U, class B = ::boost::detail::empty_base<T> > struct totally_ordered2 : less_than_comparable2<T, U , equality_comparable2<T, U, B > > {
     };
        namespace python {
      struct instance_holder : private noncopyable {
    };
      namespace detail {
    template <class T> struct is_auto_ptr : mpl::false_ {
    };
    }
      namespace detail {
    template <class T> struct copy_ctor_mutates_rhs : is_auto_ptr<T> {
   };
    }
     }
        namespace python {
      namespace detail {
    template <bool is_ptr = true> struct pointee_impl {
    };
    };
      };
        namespace python {
      namespace detail {
    }
      }
        namespace mpl {
      namespace aux {
    template< long C_ > struct not_impl : bool_<!C_> {
    };
    }
      }
        namespace python {
      namespace objects {
    template <class Pointer, class Value> struct pointer_holder_back_reference : instance_holder {
    pointer_holder_back_reference(Pointer);
    private: Pointer m_p;
    };
    template <class Pointer, class Value> inline pointer_holder_back_reference<Pointer,Value>::pointer_holder_back_reference(Pointer p) : m_p(p) {
    }
    }
     }
        namespace detail {
      class alignment_dummy;
      typedef void (*function_ptr)();
      typedef int (alignment_dummy::*member_ptr);
      typedef int (alignment_dummy::*member_function_ptr)();
      template <bool found, std::size_t target, class TestType> struct lower_alignment_helper {
    };
      template <typename T> struct has_one_T {
    };
      template <std::size_t target> union lower_alignment {
    enum {
    found0 = false };
    enum {
    found1 = lower_alignment_helper<found0,target,char >::value };
    enum {
    found2 = lower_alignment_helper<found1,target,short >::value };
    enum {
    found3 = lower_alignment_helper<found2,target,int >::value };
    enum {
    found4 = lower_alignment_helper<found3,target,long >::value };
    enum {
    found5 = lower_alignment_helper<found4,target,::boost::long_long_type >::value };
    enum {
    found6 = lower_alignment_helper<found5,target,float >::value };
    enum {
    found7 = lower_alignment_helper<found6,target,double >::value };
    enum {
    found8 = lower_alignment_helper<found7,target,long double >::value };
    enum {
    found9 = lower_alignment_helper<found8,target,void* >::value };
    enum {
    found10 = lower_alignment_helper<found9,target,function_ptr >::value };
    enum {
    found11 = lower_alignment_helper<found10,target,member_ptr >::value };
    enum {
    found12 = lower_alignment_helper<found11,target,member_function_ptr >::value };
    enum {
    found13 = lower_alignment_helper<found12,target,boost::detail::has_one_T< char > >::value };
    enum {
    found14 = lower_alignment_helper<found13,target,boost::detail::has_one_T< short > >::value };
    enum {
    found15 = lower_alignment_helper<found14,target,boost::detail::has_one_T< int > >::value };
    enum {
    found16 = lower_alignment_helper<found15,target,boost::detail::has_one_T< long > >::value };
    enum {
    found17 = lower_alignment_helper<found16,target,boost::detail::has_one_T< ::boost::long_long_type > >::value };
    enum {
    found18 = lower_alignment_helper<found17,target,boost::detail::has_one_T< float > >::value };
    enum {
    found19 = lower_alignment_helper<found18,target,boost::detail::has_one_T< double > >::value };
    enum {
    found20 = lower_alignment_helper<found19,target,boost::detail::has_one_T< long double > >::value };
    };
     }
        namespace python {
      namespace detail {
    template <std::size_t size> union aligned_storage {
    };
    }
      namespace converter {
    template <class T> struct rvalue_from_python_storage {
    };
    template <class T> struct rvalue_from_python_data : rvalue_from_python_storage<T> {
    ~rvalue_from_python_data();
    };
    namespace detail {
    };
    }
     }
        namespace mpl {
      namespace aux {
     };
      }
        namespace python {
      namespace detail {
    enum {
    };
    }
      template <class T, class MakeHolder> struct to_python_indirect {
    };
      namespace detail {
    struct make_owning_holder {
    };
    namespace detail {
    }
    }
      namespace converter {
    template <class Object, PyTypeObject* pytype> struct pyobject_type {
    static bool check(PyObject* x) {
    }
    };
    template <class> struct pyobject_traits;
    template <class T> struct handle_object_manager_traits : pyobject_traits<typename T::element_type> {
    static null_ok<typename T::element_type>* adopt(PyObject* p) {
    }
    };
    template <class T> struct default_object_manager_traits {
    static const bool is_specialized = python::detail::is_borrowed_ptr<T>::value ;
    };
    template <class T> struct object_manager_traits : mpl::if_c< is_handle<T>::value , handle_object_manager_traits<T> , default_object_manager_traits<T> >::type {
    };
    template <class T> struct is_object_manager : mpl::bool_<object_manager_traits<T>::is_specialized> {
    };
    }
      namespace detail {
    template <class X_> struct value_is_shared_ptr {
    };
    }
     }
        namespace python {
      namespace detail {
    struct signature_element {
    };
    template <unsigned> struct signature_arity;
    template <> struct signature_arity<11> {
    template <class Sig> struct impl {
    };
    };
    }
      namespace api {
    class object;
    }
      using api::object;
      namespace detail {
    template <class T, class U> struct dependent {
    };
    }
     }
        namespace detail{
      template <typename T, bool isp, bool b1> struct ct_imp {
    typedef const T& param_type;
    };
      }
        template <typename T> struct call_traits {
      typedef typename boost::detail::ct_imp< T, ::boost::is_pointer<T>::value, ::boost::is_arithmetic<T>::value >::param_type param_type;
      };
        namespace python {
      namespace detail {
    }
      namespace converter {
    namespace detail {
    template <class T> struct return_object_manager_from_python {
    typedef T result_type;
    result_type operator()(PyObject*) const;
    };
    template <class T> inline T return_object_manager_from_python<T>::operator()(PyObject* obj) const {
    }
    }
    }
      template <class DerivedVisitor> class def_visitor {
    };
      namespace api {
    template <class U> class object_operators : public def_visitor<U> {
    template < class A0 , class A1 , class A2 , class A3 , class A4 , class A5 , class A6 , class A7 , class A8 , class A9 , class A10 , class A11 , class A12> typename detail::dependent<object, A0>::type operator()( A0 const& a0 , A1 const& a1 , A2 const& a2 , A3 const& a3 , A4 const& a4 , A5 const& a5 , A6 const& a6 , A7 const& a7 , A8 const& a8 , A9 const& a9 , A10 const& a10 , A11 const& a11 , A12 const& a12) const {
    }
    };
    struct object_base : object_operators<object> {
    };
    }
      namespace converter {
    template <class Ptr> struct extract_pointer {
    };
    template <class Ref> struct extract_reference {
    };
    template <class T> struct extract_rvalue : private noncopyable {
    typedef typename mpl::if_< python::detail::copy_ctor_mutates_rhs<T> , T& , typename call_traits<T>::param_type >::type result_type;
    mutable rvalue_from_python_data<T> m_data;
    };
    template <class T> struct extract_object_manager {
    };
    template <class T> struct select_extract {
    static const bool obj_mgr = is_object_manager<T>::value ;
    static const bool ptr = is_pointer<T>::value ;
    static const bool ref = is_reference<T>::value ;
    typedef typename mpl::if_c< obj_mgr , extract_object_manager<T> , typename mpl::if_c< ptr , extract_pointer<T> , typename mpl::if_c< ref , extract_reference<T> , extract_rvalue<T> >::type >::type >::type type;
    };
    }
      template <class T> struct extract : converter::select_extract<T>::type {
    private: typedef typename converter::select_extract<T>::type base;
    public: typedef typename base::result_type result_type;
    operator result_type() const {
    }
    extract(api::object const&);
    };
      }
       }
           namespace PySide {
        class __attribute__ ((visibility("default"))) wrapper {
      };
        }
          struct QHashData {
        static QHashData shared_null;
        };
          template <class Key, class T> class QHash {
        union {
      QHashData *d;
      };
        public: inline QHash() : d(&QHashData::shared_null) {
      }
        T &operator[](const Key &key);
        };
          namespace PySide {
        template<class T> inline boost::python::handle<> ptr(T* data, bool take_ownership = false) {
      }
        class __attribute__ ((visibility("internal"))) type_details {
      typedef QGenericArgument(*func_python_to_cpp_type)(const boost::python::object&, const char*);
      public: template<typename T> static type_details* create_object_type_details(const char* type_name) {
    }
      template<typename T> static type_details* create_value_type_details(const char* type_name) {
    type_details* self = new type_details();
    self->m_func_python_to_cpp = &python_to_value_type<T>;
    }
      func_python_to_cpp_type m_func_python_to_cpp;
      template <class T> static QGenericArgument python_to_value_type(const boost::python::object& obj, const char *type_name) {
    T* val = new T(boost::python::extract<T>(obj));
    }
      };
        class __attribute__ ((visibility("default"))) type_manager {
      public: static type_manager& instance();
      template<typename T> void __attribute__ ((visibility("internal"))) register_value_type(const char* type_name) {
    m_type_map[type_name] = type_details::create_value_type_details<T>(type_name);
    }
      QHash<QString, type_details* > m_type_map;
      };
        }
          using namespace PySide;
          class __attribute__ ((visibility("internal"))) qwebpage_extensionoption_wrapper : public QWebPage::ExtensionOption, public PySide::wrapper {
        static void define_python_class() throw();
        };
          void qwebpage_extensionoption_wrapper::define_python_class() throw() {
        type_manager::instance().register_value_type<QWebPage::ExtensionOption >("QWebPage::ExtensionOption");
        }