struct QObjectData {
	int ()(void) * *           _vptr.QObjectData;    /*     0     4 */
	class QObject *            q_ptr;                /*     4     4 */
	class QObject *            parent;               /*     8     4 */
	QObjectList                children;             /*    12     4 */
	uint                       isWidget:1;           /*    16     4 */
	uint                       pendTimer:1;          /*    16     4 */
	uint                       blockSig:1;           /*    16     4 */
	uint                       wasDeleted:1;         /*    16     4 */
	uint                       ownObjectName:1;      /*    16     4 */
	uint                       sendChildEvents:1;    /*    16     4 */
	uint                       receiveChildEvents:1; /*    16     4 */
	uint                       unused:25;            /*    16     4 */
	int                        postedEvents;         /*    20     4 */
	int                        postedChildInsertedEvents; /*    24     4 */
	void QObjectData(class QObjectData *, const class QObjectData  &);

	void ~QObjectData(class QObjectData *, int);

}; /* size: 28, cachelines: 1 */
   /* last cacheline: 28 bytes */
   /* definitions: 1 */

struct QConfFileSettingsPrivate : public QSettingsPrivate {
public:

	struct QSettingsPrivate    (null);               /*     0    76 */
private:

	/* --- cacheline 1 boundary (64 bytes) was 12 bytes ago --- */
	class QConfFile *          confFiles[4];         /*    76    16 */
	enum Format                format;               /*    92     4 */
	bool                       (*readFunc)(class QIODevice &, class QMap<QString,QVariant> &); /*    96     4 */
	bool                       (*writeFunc)(class QIODevice &, const class QMap<QString,QVariant>  &); /*   100     4 */
	struct QString             extension;            /*   104     4 */
	enum CaseSensitivity       caseSensitivity;      /*   108     4 */
	void QConfFileSettingsPrivate(class QConfFileSettingsPrivate *, const class QConfFileSettingsPrivate  &);

	void QConfFileSettingsPrivate(class QConfFileSettingsPrivate *, enum Format, enum Scope, const class QString  &, const class QString  &);

	void QConfFileSettingsPrivate(class QConfFileSettingsPrivate *, const class QString  &, enum Format);

	void ~QConfFileSettingsPrivate(class QConfFileSettingsPrivate *, int);

	void remove(class QConfFileSettingsPrivate *, const class QString  &);

	void set(class QConfFileSettingsPrivate *, const class QString  &, const class QVariant  &);

	bool get(const class QConfFileSettingsPrivate  *, const class QString  &, class QVariant *);

	class QStringList children(const class QConfFileSettingsPrivate  *, const class QString  &, enum ChildSpec);

	void clear(class QConfFileSettingsPrivate *);

	void sync(class QConfFileSettingsPrivate *);

	void flush(class QConfFileSettingsPrivate *);

	bool isWritable(const class QConfFileSettingsPrivate  *);

	class QString fileName(const class QConfFileSettingsPrivate  *);

	bool readIniFile(const class QByteArray  &, UnparsedSettingsMap *);

	bool readIniSection(const class QSettingsKey  &, const class QByteArray  &, ParsedSettingsMap *);

	bool readIniLine(const class QByteArray  &, int &, int &, int &, int &);

	void initFormat(class QConfFileSettingsPrivate *);

	void initAccess(class QConfFileSettingsPrivate *);

	void syncConfFile(class QConfFileSettingsPrivate *, int);

	bool writeIniFile(class QConfFileSettingsPrivate *, class QIODevice &, const ParsedSettingsMap  &);

	void ensureAllSectionsParsed(const class QConfFileSettingsPrivate  *, class QConfFile *);

	void ensureSectionParsed(const class QConfFileSettingsPrivate  *, class QConfFile *, const class QSettingsKey  &);

}; /* size: 112, cachelines: 2 */
   /* last cacheline: 48 bytes */
   /* definitions: 1 */

struct map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > {
private:

	struct _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > _M_t; /*     0    24 */
	struct value_compare {
	}; /* size: 0, cachelines: 0 */

	void map(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *);

	void map(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *, const class less<QString>  &, const class allocator<std::pair<const QString, QVariant> >  &);

	void map(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *, const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  &);

	class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > & operator=(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *, const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  &);

	class allocator<std::pair<const QString, QVariant> > get_allocator(const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  *);

	class _Rb_tree_iterator<std::pair<const QString, QVariant> > begin(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *);

	class _Rb_tree_const_iterator<std::pair<const QString, QVariant> > begin(const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  *);

	class _Rb_tree_iterator<std::pair<const QString, QVariant> > end(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *);

	class _Rb_tree_const_iterator<std::pair<const QString, QVariant> > end(const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  *);

	class reverse_iterator<std::_Rb_tree_iterator<std::pair<const QString, QVariant> > > rbegin(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *);

	class reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const QString, QVariant> > > rbegin(const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  *);

	class reverse_iterator<std::_Rb_tree_iterator<std::pair<const QString, QVariant> > > rend(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *);

	class reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const QString, QVariant> > > rend(const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  *);

	bool empty(const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  *);

	size_t size(const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  *);

	size_t max_size(const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  *);

	class QVariant & operator[](class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *, const class QString  &);

	class QVariant & at(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *, const class QString  &);

	const class QVariant  & at(const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  *, const class QString  &);

	class pair<std::_Rb_tree_iterator<std::pair<const QString, QVariant> >,bool> insert(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *, const class pair<const QString,QVariant>  &);

	class _Rb_tree_iterator<std::pair<const QString, QVariant> > insert(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *, class _Rb_tree_iterator<std::pair<const QString, QVariant> >, const class pair<const QString,QVariant>  &);

	void erase(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *, class _Rb_tree_iterator<std::pair<const QString, QVariant> >);

	size_t erase(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *, const class QString  &);

	void erase(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *, class _Rb_tree_iterator<std::pair<const QString, QVariant> >, class _Rb_tree_iterator<std::pair<const QString, QVariant> >);

	void swap(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *, class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > &);

	void clear(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *);

	class less<QString> key_comp(const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  *);

	class value_compare value_comp(const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  *);

	class _Rb_tree_iterator<std::pair<const QString, QVariant> > find(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *, const class QString  &);

	class _Rb_tree_const_iterator<std::pair<const QString, QVariant> > find(const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  *, const class QString  &);

	size_t count(const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  *, const class QString  &);

	class _Rb_tree_iterator<std::pair<const QString, QVariant> > lower_bound(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *, const class QString  &);

	class _Rb_tree_const_iterator<std::pair<const QString, QVariant> > lower_bound(const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  *, const class QString  &);

	class _Rb_tree_iterator<std::pair<const QString, QVariant> > upper_bound(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *, const class QString  &);

	class _Rb_tree_const_iterator<std::pair<const QString, QVariant> > upper_bound(const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  *, const class QString  &);

	class pair<std::_Rb_tree_iterator<std::pair<const QString, QVariant> >,std::_Rb_tree_iterator<std::pair<const QString, QVariant equal_range(class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > *, const class QString  &);

	class pair<std::_Rb_tree_const_iterator<std::pair<const QString, QVariant> >,std::_Rb_tree_const_iterator<std::pair<const QStri equal_range(const class map<QString,QVariant,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > >  *, const class QString  &);

}; /* size: 24, cachelines: 1 */
   /* last cacheline: 24 bytes */
   /* definitions: 1 */

struct _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QString>,std::allocator<std::pair<const QString, QVariant> > > {
protected:

	struct _Rb_tree_impl<std::less<QString>,false> _M_impl; /*     0    24 */
	class allocator<std::pair<const QString, QVariant> > get_allocator(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

	class _Rb_tree_node<std::pair<const QString, QVariant> > * _M_get_node(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin);

	void _M_put_node(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, class _Rb_tree_node<std::pair<const QString, QVariant> > *);

	class _Rb_tree_node<std::pair<const QString, QVariant> > * _M_create_node(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, const class pair<const QString,QVariant>  &);

	class _Rb_tree_node<std::pair<const QString, QVariant> > * _M_clone_node(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, const class _Rb_tree_node<std::pair<const QString, QVariant> >  *);

	void destroy_node(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, class _Rb_tree_node<std::pair<const QString, QVariant> > *);

	class _Rb_tree_node_base * & _M_root(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin);

	const class _Rb_tree_node_base  * _M_root(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

	class _Rb_tree_node_base * & _M_leftmost(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin);

	const class _Rb_tree_node_base  * _M_leftmost(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

	class _Rb_tree_node_base * & _M_rightmost(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin);

	const class _Rb_tree_node_base  * _M_rightmost(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

	class _Rb_tree_node<std::pair<const QString, QVariant> > * _M_begin(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin);

	const class _Rb_tree_node<std::pair<const QString, QVariant> >  * _M_begin(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

	class _Rb_tree_node<std::pair<const QString, QVariant> > * _M_end(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin);

	const class _Rb_tree_node<std::pair<const QString, QVariant> >  * _M_end(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

	const class pair<const QString,QVariant>  & _S_value(const class _Rb_tree_node<std::pair<const QString, QVariant> >  *);

	const class QString  & _S_key(const class _Rb_tree_node<std::pair<const QString, QVariant> >  *);

	class _Rb_tree_node<std::pair<const QString, QVariant> > * _S_left(class _Rb_tree_node_base *);

	const class _Rb_tree_node<std::pair<const QString, QVariant> >  * _S_left(const class _Rb_tree_node_base  *);

	class _Rb_tree_node<std::pair<const QString, QVariant> > * _S_right(class _Rb_tree_node_base *);

	const class _Rb_tree_node<std::pair<const QString, QVariant> >  * _S_right(const class _Rb_tree_node_base  *);

	const class pair<const QString,QVariant>  & _S_value(const class _Rb_tree_node_base  *);

	const class QString  & _S_key(const class _Rb_tree_node_base  *);

	class _Rb_tree_node_base * _S_minimum(class _Rb_tree_node_base *);

	const class _Rb_tree_node_base  * _S_minimum(const class _Rb_tree_node_base  *);

	class _Rb_tree_node_base * _S_maximum(class _Rb_tree_node_base *);

	const class _Rb_tree_node_base  * _S_maximum(const class _Rb_tree_node_base  *);

private:

	class _Rb_tree_iterator<std::pair<const QString, QVariant> > _M_insert(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, class _Rb_tree_node_base *, class _Rb_tree_node_base *, const class pair<const QString,QVariant>  &);

	class _Rb_tree_const_iterator<std::pair<const QString, QVariant> > _M_insert(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, const class _Rb_tree_node_base  *, const class _Rb_tree_node_base  *, const class pair<const QString,QVariant>  &);

	class _Rb_tree_node<std::pair<const QString, QVariant> > * _M_copy(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, const class _Rb_tree_node<std::pair<const QString, QVariant> >  *, class _Rb_tree_node<std::pair<const QString, QVariant> > *);

	void _M_erase(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, class _Rb_tree_node<std::pair<const QString, QVariant> > *);

	void _Rb_tree(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin);

	void _Rb_tree(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, const class less<QString>  &);

	void _Rb_tree(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, const class less<QString>  &, const class allocator<std::pair<const QString, QVariant> >  &);

	void _Rb_tree(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

	void ~_Rb_tree(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, int);

	class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin operator=(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

	class less<QString> key_comp(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

	class _Rb_tree_iterator<std::pair<const QString, QVariant> > begin(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin);

	class _Rb_tree_const_iterator<std::pair<const QString, QVariant> > begin(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

	class _Rb_tree_iterator<std::pair<const QString, QVariant> > end(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin);

	class _Rb_tree_const_iterator<std::pair<const QString, QVariant> > end(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

	class reverse_iterator<std::_Rb_tree_iterator<std::pair<const QString, QVariant> > > rbegin(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin);

	class reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const QString, QVariant> > > rbegin(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

	class reverse_iterator<std::_Rb_tree_iterator<std::pair<const QString, QVariant> > > rend(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin);

	class reverse_iterator<std::_Rb_tree_const_iterator<std::pair<const QString, QVariant> > > rend(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

	bool empty(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

	size_t size(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

	size_t max_size(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

	void swap(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin);

	class pair<std::_Rb_tree_iterator<std::pair<const QString, QVariant> >,bool> insert_unique(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, const class pair<const QString,QVariant>  &);

	class _Rb_tree_iterator<std::pair<const QString, QVariant> > insert_equal(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, const class pair<const QString,QVariant>  &);

	class _Rb_tree_iterator<std::pair<const QString, QVariant> > insert_unique(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, class _Rb_tree_iterator<std::pair<const QString, QVariant> >, const class pair<const QString,QVariant>  &);

	class _Rb_tree_const_iterator<std::pair<const QString, QVariant> > insert_unique(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, class _Rb_tree_const_iterator<std::pair<const QString, QVariant> >, const class pair<const QString,QVariant>  &);

	class _Rb_tree_iterator<std::pair<const QString, QVariant> > insert_equal(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, class _Rb_tree_iterator<std::pair<const QString, QVariant> >, const class pair<const QString,QVariant>  &);

	class _Rb_tree_const_iterator<std::pair<const QString, QVariant> > insert_equal(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, class _Rb_tree_const_iterator<std::pair<const QString, QVariant> >, const class pair<const QString,QVariant>  &);

	void erase(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, class _Rb_tree_iterator<std::pair<const QString, QVariant> >);

	void erase(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, class _Rb_tree_const_iterator<std::pair<const QString, QVariant> >);

	size_t erase(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, const class QString  &);

	void erase(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, class _Rb_tree_iterator<std::pair<const QString, QVariant> >, class _Rb_tree_iterator<std::pair<const QString, QVariant> >);

	void erase(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, class _Rb_tree_const_iterator<std::pair<const QString, QVariant> >, class _Rb_tree_const_iterator<std::pair<const QString, QVariant> >);

	void erase(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, const class QString  *, const class QString  *);

	void clear(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin);

	class _Rb_tree_iterator<std::pair<const QString, QVariant> > find(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, const class QString  &);

	class _Rb_tree_const_iterator<std::pair<const QString, QVariant> > find(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<, const class QString  &);

	size_t count(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<, const class QString  &);

	class _Rb_tree_iterator<std::pair<const QString, QVariant> > lower_bound(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, const class QString  &);

	class _Rb_tree_const_iterator<std::pair<const QString, QVariant> > lower_bound(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<, const class QString  &);

	class _Rb_tree_iterator<std::pair<const QString, QVariant> > upper_bound(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, const class QString  &);

	class _Rb_tree_const_iterator<std::pair<const QString, QVariant> > upper_bound(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<, const class QString  &);

	class pair<std::_Rb_tree_iterator<std::pair<const QString, QVariant> >,std::_Rb_tree_iterator<std::pair<const QString, QVariant equal_range(class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<QStrin, const class QString  &);

	class pair<std::_Rb_tree_const_iterator<std::pair<const QString, QVariant> >,std::_Rb_tree_const_iterator<std::pair<const QStri equal_range(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<, const class QString  &);

	bool __rb_verify(const class _Rb_tree<QString,std::pair<const QString, QVariant>,std::_Select1st<std::pair<const QString, QVariant> >,std::less<);

}; /* size: 24, cachelines: 1 */
   /* last cacheline: 24 bytes */
   /* definitions: 1 */

struct less<QString> : public binary_function<QString,QString,bool> {
public:

	struct binary_function<QString,QString,bool> (null); /*     0     1 */

	/* XXX last struct has 1 byte of padding */
	bool operator()(const class less<QString>  *, const class QString  &, const class QString  &);

}; /* size: 1, cachelines: 1 */
   /* paddings: 1, sum paddings: 1 */
   /* last cacheline: 1 bytes */
   /* definitions: 1 */

struct binary_function<QString,QString,bool> {
}; /* size: 1, cachelines: 1 */
   /* padding: 1 */
   /* last cacheline: 1 bytes */
   /* definitions: 1 */

struct allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > > : public new_allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > > {
public:

	struct new_allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > > (null); /*     0     1 */

	/* XXX last struct has 1 byte of padding */
	void allocator(class allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > > *);

	void allocator(class allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > > *, const class allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > >  &);

	void ~allocator(class allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > > *, int);

}; /* size: 1, cachelines: 1 */
   /* paddings: 1, sum paddings: 1 */
   /* last cacheline: 1 bytes */
   /* definitions: 1 */

struct new_allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > > {
	void new_allocator(class new_allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > > *);

	void new_allocator(class new_allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > > *, const class new_allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > >  &);

	void ~new_allocator(class new_allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > > *, int);

	class _Rb_tree_node<std::pair<const QString, QVariant> > * address(const class new_allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > >  *, class _Rb_tree_node<std::pair<const QString, QVariant> > &);

	const class _Rb_tree_node<std::pair<const QString, QVariant> >  * address(const class new_allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > >  *, const class _Rb_tree_node<std::pair<const QString, QVariant> >  &);

	class _Rb_tree_node<std::pair<const QString, QVariant> > * allocate(class new_allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > > *, unsigned int, const void  *);

	void deallocate(class new_allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > > *, class _Rb_tree_node<std::pair<const QString, QVariant> > *, unsigned int);

	size_t max_size(const class new_allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > >  *);

	void construct(class new_allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > > *, class _Rb_tree_node<std::pair<const QString, QVariant> > *, const class _Rb_tree_node<std::pair<const QString, QVariant> >  &);

	void destroy(class new_allocator<std::_Rb_tree_node<std::pair<const QString, QVariant> > > *, class _Rb_tree_node<std::pair<const QString, QVariant> > *);

}; /* size: 1, cachelines: 1 */
   /* padding: 1 */
   /* last cacheline: 1 bytes */
   /* definitions: 1 */

struct allocator<std::pair<const QString, QVariant> > : public new_allocator<std::pair<const QString, QVariant> > {
public:

	struct new_allocator<std::pair<const QString, QVariant> > (null); /*     0     1 */

	/* XXX last struct has 1 byte of padding */
	void allocator(class allocator<std::pair<const QString, QVariant> > *);

	void allocator(class allocator<std::pair<const QString, QVariant> > *, const class allocator<std::pair<const QString, QVariant> >  &);

	void ~allocator(class allocator<std::pair<const QString, QVariant> > *, int);

}; /* size: 1, cachelines: 1 */
   /* paddings: 1, sum paddings: 1 */
   /* last cacheline: 1 bytes */
   /* definitions: 1 */

struct new_allocator<std::pair<const QString, QVariant> > {
	void new_allocator(class new_allocator<std::pair<const QString, QVariant> > *);

	void new_allocator(class new_allocator<std::pair<const QString, QVariant> > *, const class new_allocator<std::pair<const QString, QVariant> >  &);

	void ~new_allocator(class new_allocator<std::pair<const QString, QVariant> > *, int);

	class pair<const QString,QVariant> * address(const class new_allocator<std::pair<const QString, QVariant> >  *, class pair<const QString,QVariant> &);

	const class pair<const QString,QVariant>  * address(const class new_allocator<std::pair<const QString, QVariant> >  *, const class pair<const QString,QVariant>  &);

	class pair<const QString,QVariant> * allocate(class new_allocator<std::pair<const QString, QVariant> > *, unsigned int, const void  *);

	void deallocate(class new_allocator<std::pair<const QString, QVariant> > *, class pair<const QString,QVariant> *, unsigned int);

	size_t max_size(const class new_allocator<std::pair<const QString, QVariant> >  *);

	void construct(class new_allocator<std::pair<const QString, QVariant> > *, class pair<const QString,QVariant> *, const class pair<const QString,QVariant>  &);

	void destroy(class new_allocator<std::pair<const QString, QVariant> > *, class pair<const QString,QVariant> *);

}; /* size: 1, cachelines: 1 */
   /* padding: 1 */
   /* last cacheline: 1 bytes */
   /* definitions: 1 */

struct Node {
	void *                     v;                    /*     0     4 */
	class QByteArray & t(class Node *);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 11 */

struct QMap<QString,QMap<QString, QVariant> > {
	union ._117 {
		class QMapData *           d;                    /*           4 */
		class Node *               e;                    /*           4 */
	};

private:

	union ._117                (null);               /*     0     4 */
	struct Node {
	}; /* size: 0, cachelines: 0 */

	struct const_iterator {
	}; /* size: 0, cachelines: 0 */

	struct iterator {
	}; /* size: 0, cachelines: 0 */

	int payload(void);

	class Node * concrete(class Node *);

	void QMap(class QMap<QString,QMap<QString, QVariant> > *);

	void QMap(class QMap<QString,QMap<QString, QVariant> > *, const class QMap<QString,QMap<QString, QVariant> >  &);

	void ~QMap(class QMap<QString,QMap<QString, QVariant> > *, int);

	class QMap<QString,QMap<QString, QVariant> > & operator=(class QMap<QString,QMap<QString, QVariant> > *, const class QMap<QString,QMap<QString, QVariant> >  &);

	void QMap(class QMap<QString,QMap<QString, QVariant> > *, const class map<QString,QMap<QString, QVariant>,std::less<QString>,std::allocator<std::pair<const QString, QMap<QString, QVaria);

	class map<QString,QMap<QString, QVariant>,std::less<QString>,std::allocator<std::pair<const QString, QMap<QString, QVariant> >  toStdMap(const class QMap<QString,QMap<QString, QVariant> >  *);

	bool operator==(const class QMap<QString,QMap<QString, QVariant> >  *, const class QMap<QString,QMap<QString, QVariant> >  &);

	bool operator!=(const class QMap<QString,QMap<QString, QVariant> >  *, const class QMap<QString,QMap<QString, QVariant> >  &);

	int size(const class QMap<QString,QMap<QString, QVariant> >  *);

	bool isEmpty(const class QMap<QString,QMap<QString, QVariant> >  *);

	void detach(class QMap<QString,QMap<QString, QVariant> > *);

	bool isDetached(const class QMap<QString,QMap<QString, QVariant> >  *);

	void setSharable(class QMap<QString,QMap<QString, QVariant> > *, bool);

	void clear(class QMap<QString,QMap<QString, QVariant> > *);

	int remove(class QMap<QString,QMap<QString, QVariant> > *, const class QString  &);

	class QMap<QString,QVariant> take(class QMap<QString,QMap<QString, QVariant> > *, const class QString  &);

	bool contains(const class QMap<QString,QMap<QString, QVariant> >  *, const class QString  &);

	const class QString  key(const class QMap<QString,QMap<QString, QVariant> >  *, const class QMap<QString,QVariant>  &);

	const class QMap<QString,QVariant>  value(const class QMap<QString,QMap<QString, QVariant> >  *, const class QString  &);

	const class QMap<QString,QVariant>  value(const class QMap<QString,QMap<QString, QVariant> >  *, const class QString  &, const class QMap<QString,QVariant>  &);

	class QMap<QString,QVariant> & operator[](class QMap<QString,QMap<QString, QVariant> > *, const class QString  &);

	const class QMap<QString,QVariant>  operator[](const class QMap<QString,QMap<QString, QVariant> >  *, const class QString  &);

	class QList<QString> uniqueKeys(const class QMap<QString,QMap<QString, QVariant> >  *);

	class QList<QString> keys(const class QMap<QString,QMap<QString, QVariant> >  *);

	class QList<QString> keys(const class QMap<QString,QMap<QString, QVariant> >  *, const class QMap<QString,QVariant>  &);

	class QList<QMap<QString, QVariant> > values(const class QMap<QString,QMap<QString, QVariant> >  *);

	class QList<QMap<QString, QVariant> > values(const class QMap<QString,QMap<QString, QVariant> >  *, const class QString  &);

	int count(const class QMap<QString,QMap<QString, QVariant> >  *, const class QString  &);

	class iterator begin(class QMap<QString,QMap<QString, QVariant> > *);

	class const_iterator begin(const class QMap<QString,QMap<QString, QVariant> >  *);

	class const_iterator constBegin(const class QMap<QString,QMap<QString, QVariant> >  *);

	class iterator end(class QMap<QString,QMap<QString, QVariant> > *);

	class const_iterator end(const class QMap<QString,QMap<QString, QVariant> >  *);

	class const_iterator constEnd(const class QMap<QString,QMap<QString, QVariant> >  *);

	class iterator erase(class QMap<QString,QMap<QString, QVariant> > *, class iterator);

	class iterator remove(class QMap<QString,QMap<QString, QVariant> > *, class iterator);

	void erase(class QMap<QString,QMap<QString, QVariant> > *, const class QString  &);

	int count(const class QMap<QString,QMap<QString, QVariant> >  *);

	class iterator find(class QMap<QString,QMap<QString, QVariant> > *, const class QString  &);

	class const_iterator find(const class QMap<QString,QMap<QString, QVariant> >  *, const class QString  &);

	class const_iterator constFind(const class QMap<QString,QMap<QString, QVariant> >  *, const class QString  &);

	class iterator lowerBound(class QMap<QString,QMap<QString, QVariant> > *, const class QString  &);

	class const_iterator lowerBound(const class QMap<QString,QMap<QString, QVariant> >  *, const class QString  &);

	class iterator upperBound(class QMap<QString,QMap<QString, QVariant> > *, const class QString  &);

	class const_iterator upperBound(const class QMap<QString,QMap<QString, QVariant> >  *, const class QString  &);

	class iterator insert(class QMap<QString,QMap<QString, QVariant> > *, const class QString  &, const class QMap<QString,QVariant>  &);

	class iterator insert(class QMap<QString,QMap<QString, QVariant> > *, const class QString  &, const class QMap<QString,QVariant>  &, bool);

	class iterator insertMulti(class QMap<QString,QMap<QString, QVariant> > *, const class QString  &, const class QMap<QString,QVariant>  &);

	class iterator replace(class QMap<QString,QMap<QString, QVariant> > *, const class QString  &, const class QMap<QString,QVariant>  &);

	class QMap<QString,QMap<QString, QVariant> > & unite(class QMap<QString,QMap<QString, QVariant> > *, const class QMap<QString,QMap<QString, QVariant> >  &);

	bool empty(const class QMap<QString,QMap<QString, QVariant> >  *);

	void detach_helper(class QMap<QString,QMap<QString, QVariant> > *);

	void freeData(class QMap<QString,QMap<QString, QVariant> > *, class QMapData *);

	class Node * findNode(const class QMap<QString,QMap<QString, QVariant> >  *, const class QString  &);

	class Node * mutableFindNode(const class QMap<QString,QMap<QString, QVariant> >  *, class Node * *, const class QString  &);

	class Node * node_create(class QMap<QString,QMap<QString, QVariant> > *, class QMapData *, class Node * *, const class QString  &, const class QMap<QString,QVariant>  &);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QMap<QString,QString> {
	union ._117 {
		class QMapData *           d;                    /*           4 */
		class Node *               e;                    /*           4 */
	};

private:

	union ._117                (null);               /*     0     4 */
	struct Node {
	}; /* size: 0, cachelines: 0 */

	struct const_iterator {
	}; /* size: 0, cachelines: 0 */

	struct iterator {
	}; /* size: 0, cachelines: 0 */

	int payload(void);

	class Node * concrete(class Node *);

	void QMap(class QMap<QString,QString> *);

	void QMap(class QMap<QString,QString> *, const class QMap<QString,QString>  &);

	void ~QMap(class QMap<QString,QString> *, int);

	class QMap<QString,QString> & operator=(class QMap<QString,QString> *, const class QMap<QString,QString>  &);

	void QMap(class QMap<QString,QString> *, const class map<QString,QString,std::less<QString>,std::allocator<std::pair<const QString, QString> > >  &);

	class map<QString,QString,std::less<QString>,std::allocator<std::pair<const QString, QString> > > toStdMap(const class QMap<QString,QString>  *);

	bool operator==(const class QMap<QString,QString>  *, const class QMap<QString,QString>  &);

	bool operator!=(const class QMap<QString,QString>  *, const class QMap<QString,QString>  &);

	int size(const class QMap<QString,QString>  *);

	bool isEmpty(const class QMap<QString,QString>  *);

	void detach(class QMap<QString,QString> *);

	bool isDetached(const class QMap<QString,QString>  *);

	void setSharable(class QMap<QString,QString> *, bool);

	void clear(class QMap<QString,QString> *);

	int remove(class QMap<QString,QString> *, const class QString  &);

	class QString take(class QMap<QString,QString> *, const class QString  &);

	bool contains(const class QMap<QString,QString>  *, const class QString  &);

	const class QString  key(const class QMap<QString,QString>  *, const class QString  &);

	const class QString  value(const class QMap<QString,QString>  *, const class QString  &);

	const class QString  value(const class QMap<QString,QString>  *, const class QString  &, const class QString  &);

	class QString & operator[](class QMap<QString,QString> *, const class QString  &);

	const class QString  operator[](const class QMap<QString,QString>  *, const class QString  &);

	class QList<QString> uniqueKeys(const class QMap<QString,QString>  *);

	class QList<QString> keys(const class QMap<QString,QString>  *);

	class QList<QString> keys(const class QMap<QString,QString>  *, const class QString  &);

	class QList<QString> values(const class QMap<QString,QString>  *);

	class QList<QString> values(const class QMap<QString,QString>  *, const class QString  &);

	int count(const class QMap<QString,QString>  *, const class QString  &);

	class iterator begin(class QMap<QString,QString> *);

	class const_iterator begin(const class QMap<QString,QString>  *);

	class const_iterator constBegin(const class QMap<QString,QString>  *);

	class iterator end(class QMap<QString,QString> *);

	class const_iterator end(const class QMap<QString,QString>  *);

	class const_iterator constEnd(const class QMap<QString,QString>  *);

	class iterator erase(class QMap<QString,QString> *, class iterator);

	class iterator remove(class QMap<QString,QString> *, class iterator);

	void erase(class QMap<QString,QString> *, const class QString  &);

	int count(const class QMap<QString,QString>  *);

	class iterator find(class QMap<QString,QString> *, const class QString  &);

	class const_iterator find(const class QMap<QString,QString>  *, const class QString  &);

	class const_iterator constFind(const class QMap<QString,QString>  *, const class QString  &);

	class iterator lowerBound(class QMap<QString,QString> *, const class QString  &);

	class const_iterator lowerBound(const class QMap<QString,QString>  *, const class QString  &);

	class iterator upperBound(class QMap<QString,QString> *, const class QString  &);

	class const_iterator upperBound(const class QMap<QString,QString>  *, const class QString  &);

	class iterator insert(class QMap<QString,QString> *, const class QString  &, const class QString  &);

	class iterator insert(class QMap<QString,QString> *, const class QString  &, const class QString  &, bool);

	class iterator insertMulti(class QMap<QString,QString> *, const class QString  &, const class QString  &);

	class iterator replace(class QMap<QString,QString> *, const class QString  &, const class QString  &);

	class QMap<QString,QString> & unite(class QMap<QString,QString> *, const class QMap<QString,QString>  &);

	bool empty(const class QMap<QString,QString>  *);

	void detach_helper(class QMap<QString,QString> *);

	void freeData(class QMap<QString,QString> *, class QMapData *);

	class Node * findNode(const class QMap<QString,QString>  *, const class QString  &);

	class Node * mutableFindNode(const class QMap<QString,QString>  *, class Node * *, const class QString  &);

	class Node * node_create(class QMap<QString,QString> *, class QMapData *, class Node * *, const class QString  &, const class QString  &);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct statfs {
	int                        f_type;               /*     0     4 */
	int                        f_bsize;              /*     4     4 */
	__fsblkcnt_t               f_blocks;             /*     8     4 */
	__fsblkcnt_t               f_bfree;              /*    12     4 */
	__fsblkcnt_t               f_bavail;             /*    16     4 */
	__fsfilcnt_t               f_files;              /*    20     4 */
	__fsfilcnt_t               f_ffree;              /*    24     4 */
	struct ._48                f_fsid;               /*    28     8 */
	int                        f_namelen;            /*    36     4 */
	int                        f_frsize;             /*    40     4 */
	int                        f_spare[5];           /*    44    20 */
	/* --- cacheline 1 boundary (64 bytes) --- */
}; /* size: 64, cachelines: 1 */
   /* definitions: 1 */

struct QGlobalStatic<QMutex> {
	class QMutex *             pointer;              /*     0     4 */
	bool                       destroyed;            /*     4     1 */
	void QGlobalStatic(class QGlobalStatic<QMutex> *);

	void ~QGlobalStatic(class QGlobalStatic<QMutex> *, int);

}; /* size: 8, cachelines: 1 */
   /* padding: 3 */
   /* last cacheline: 8 bytes */
   /* definitions: 1 */

struct QVectorTypedData<QConfFileCustomFormat> {
	struct QBasicAtomic        ref;                  /*     0     4 */
	int                        alloc;                /*     4     4 */
	int                        size;                 /*     8     4 */
	uint                       sharable:1;           /*    12     4 */

	/* XXX 31 bits hole, try to pack */

	class QConfFileCustomFormat array[1];            /*    16    16 */
}; /* size: 32, cachelines: 1 */
   /* bit holes: 1, sum bit holes: 31 bits */
   /* last cacheline: 32 bytes */
   /* definitions: 1 */

struct QGlobalStatic<QVector<QConfFileCustomFormat> > {
	class QVector<QConfFileCustomFormat> * pointer;  /*     0     4 */
	bool                       destroyed;            /*     4     1 */
	void QGlobalStatic(class QGlobalStatic<QVector<QConfFileCustomFormat> > *);

	void ~QGlobalStatic(class QGlobalStatic<QVector<QConfFileCustomFormat> > *, int);

}; /* size: 8, cachelines: 1 */
   /* padding: 3 */
   /* last cacheline: 8 bytes */
   /* definitions: 1 */

struct QHashNode<int,QString> {
	union ._112 {
		uint                       h;                    /*           4 */
		int                        key;                  /*           4 */
	};

	class QHashNode<int,QString> * next;             /*     0     4 */
	union ._112                (null);               /*     4     4 */
	struct QString             value;                /*     8     4 */
	void QHashNode(class QHashNode<int,QString> *, int);

	void QHashNode(class QHashNode<int,QString> *, int, const class QString  &);

	bool same_key(class QHashNode<int,QString> *, unsigned int, int);

	void ~QHashNode(class QHashNode<int,QString> *, int);

}; /* size: 12, cachelines: 1 */
   /* last cacheline: 12 bytes */
   /* definitions: 1 */

struct QGlobalStatic<QHash<int, QString> > {
	class QHash<int,QString> * pointer;              /*     0     4 */
	bool                       destroyed;            /*     4     1 */
	void QGlobalStatic(class QGlobalStatic<QHash<int, QString> > *);

	void ~QGlobalStatic(class QGlobalStatic<QHash<int, QString> > *, int);

}; /* size: 8, cachelines: 1 */
   /* padding: 3 */
   /* last cacheline: 8 bytes */
   /* definitions: 1 */

struct QHashNode<QString,QCache<QString, QConfFile>::Node> {
	class QHashNode<QString,QCache<QString, QConfFile>::Node> * next; /*     0     4 */
	uint                       h;                    /*     4     4 */
	struct QString             key;                  /*     8     4 */
	struct Node                value;                /*    12    20 */
	void QHashNode(class QHashNode<QString,QCache<QString, QConfFile>::Node> *, const class QString  &);

	void QHashNode(class QHashNode<QString,QCache<QString, QConfFile>::Node> *, const class QString  &, const class Node  &);

	bool same_key(class QHashNode<QString,QCache<QString, QConfFile>::Node> *, unsigned int, const class QString  &);

	void ~QHashNode(class QHashNode<QString,QCache<QString, QConfFile>::Node> *, int);

}; /* size: 32, cachelines: 1 */
   /* last cacheline: 32 bytes */
   /* definitions: 1 */

struct QHash<QString,QCache<QString, QConfFile>::Node> {
	union ._115 {
		class QHashData *          d;                    /*           4 */
		class QHashNode<QString,QCache<QString, QConfFile>::Node> * e; /*           4 */
	};

private:

	union ._115                (null);               /*     0     4 */
	struct const_iterator {
	}; /* size: 0, cachelines: 0 */

	struct iterator {
	}; /* size: 0, cachelines: 0 */

	class QHashNode<QString,QCache<QString, QConfFile>::Node> * concrete(class Node *);

	void QHash(class QHash<QString,QCache<QString, QConfFile>::Node> *);

	void QHash(class QHash<QString,QCache<QString, QConfFile>::Node> *, const class QHash<QString,QCache<QString, QConfFile>::Node>  &);

	void ~QHash(class QHash<QString,QCache<QString, QConfFile>::Node> *, int);

	class QHash<QString,QCache<QString, QConfFile>::Node> & operator=(class QHash<QString,QCache<QString, QConfFile>::Node> *, const class QHash<QString,QCache<QString, QConfFile>::Node>  &);

	bool operator==(const class QHash<QString,QCache<QString, QConfFile>::Node>  *, const class QHash<QString,QCache<QString, QConfFile>::Node>  &);

	bool operator!=(const class QHash<QString,QCache<QString, QConfFile>::Node>  *, const class QHash<QString,QCache<QString, QConfFile>::Node>  &);

	int size(const class QHash<QString,QCache<QString, QConfFile>::Node>  *);

	bool isEmpty(const class QHash<QString,QCache<QString, QConfFile>::Node>  *);

	int capacity(const class QHash<QString,QCache<QString, QConfFile>::Node>  *);

	void reserve(class QHash<QString,QCache<QString, QConfFile>::Node> *, int);

	void squeeze(class QHash<QString,QCache<QString, QConfFile>::Node> *);

	void detach(class QHash<QString,QCache<QString, QConfFile>::Node> *);

	bool isDetached(const class QHash<QString,QCache<QString, QConfFile>::Node>  *);

	void setSharable(class QHash<QString,QCache<QString, QConfFile>::Node> *, bool);

	void clear(class QHash<QString,QCache<QString, QConfFile>::Node> *);

	int remove(class QHash<QString,QCache<QString, QConfFile>::Node> *, const class QString  &);

	class Node take(class QHash<QString,QCache<QString, QConfFile>::Node> *, const class QString  &);

	bool contains(const class QHash<QString,QCache<QString, QConfFile>::Node>  *, const class QString  &);

	const class QString  key(const class QHash<QString,QCache<QString, QConfFile>::Node>  *, const class Node  &);

	const class Node  value(const class QHash<QString,QCache<QString, QConfFile>::Node>  *, const class QString  &);

	const class Node  value(const class QHash<QString,QCache<QString, QConfFile>::Node>  *, const class QString  &, const class Node  &);

	class Node & operator[](class QHash<QString,QCache<QString, QConfFile>::Node> *, const class QString  &);

	const class Node  operator[](const class QHash<QString,QCache<QString, QConfFile>::Node>  *, const class QString  &);

	class QList<QString> uniqueKeys(const class QHash<QString,QCache<QString, QConfFile>::Node>  *);

	class QList<QString> keys(const class QHash<QString,QCache<QString, QConfFile>::Node>  *);

	class QList<QString> keys(const class QHash<QString,QCache<QString, QConfFile>::Node>  *, const class Node  &);

	class QList<QCache<QString, QConfFile>::Node> values(const class QHash<QString,QCache<QString, QConfFile>::Node>  *);

	class QList<QCache<QString, QConfFile>::Node> values(const class QHash<QString,QCache<QString, QConfFile>::Node>  *, const class QString  &);

	int count(const class QHash<QString,QCache<QString, QConfFile>::Node>  *, const class QString  &);

	class iterator begin(class QHash<QString,QCache<QString, QConfFile>::Node> *);

	class const_iterator begin(const class QHash<QString,QCache<QString, QConfFile>::Node>  *);

	class const_iterator constBegin(const class QHash<QString,QCache<QString, QConfFile>::Node>  *);

	class iterator end(class QHash<QString,QCache<QString, QConfFile>::Node> *);

	class const_iterator end(const class QHash<QString,QCache<QString, QConfFile>::Node>  *);

	class const_iterator constEnd(const class QHash<QString,QCache<QString, QConfFile>::Node>  *);

	class iterator erase(class QHash<QString,QCache<QString, QConfFile>::Node> *, class iterator);

	int count(const class QHash<QString,QCache<QString, QConfFile>::Node>  *);

	class iterator find(class QHash<QString,QCache<QString, QConfFile>::Node> *, const class QString  &);

	class const_iterator find(const class QHash<QString,QCache<QString, QConfFile>::Node>  *, const class QString  &);

	class const_iterator constFind(const class QHash<QString,QCache<QString, QConfFile>::Node>  *, const class QString  &);

	class iterator insert(class QHash<QString,QCache<QString, QConfFile>::Node> *, const class QString  &, const class Node  &);

	class iterator insertMulti(class QHash<QString,QCache<QString, QConfFile>::Node> *, const class QString  &, const class Node  &);

	class QHash<QString,QCache<QString, QConfFile>::Node> & unite(class QHash<QString,QCache<QString, QConfFile>::Node> *, const class QHash<QString,QCache<QString, QConfFile>::Node>  &);

	bool empty(const class QHash<QString,QCache<QString, QConfFile>::Node>  *);

	void detach_helper(class QHash<QString,QCache<QString, QConfFile>::Node> *);

	void freeData(class QHash<QString,QCache<QString, QConfFile>::Node> *, class QHashData *);

	class QHashNode<QString,QCache<QString, QConfFile>::Node> * * findNode(const class QHash<QString,QCache<QString, QConfFile>::Node>  *, const class QString  &, uint *);

	class QHashNode<QString,QCache<QString, QConfFile>::Node> * createNode(class QHash<QString,QCache<QString, QConfFile>::Node> *, unsigned int, const class QString  &, const class Node  &, class QHashNode<QString,QCache<QString, QConfFile>::Node> * *);

	void deleteNode(class QHash<QString,QCache<QString, QConfFile>::Node> *, class QHashNode<QString,QCache<QString, QConfFile>::Node> *);

	void duplicateNode(class Node *, void *);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QGlobalStatic<QCache<QString, QConfFile> > {
	class QCache<QString,QConfFile> * pointer;       /*     0     4 */
	bool                       destroyed;            /*     4     1 */
	void QGlobalStatic(class QGlobalStatic<QCache<QString, QConfFile> > *);

	void ~QGlobalStatic(class QGlobalStatic<QCache<QString, QConfFile> > *, int);

}; /* size: 8, cachelines: 1 */
   /* padding: 3 */
   /* last cacheline: 8 bytes */
   /* definitions: 1 */

struct QHashNode<QString,QConfFile*> {
	class QHashNode<QString,QConfFile*> * next;      /*     0     4 */
	uint                       h;                    /*     4     4 */
	struct QString             key;                  /*     8     4 */
	class QConfFile *          value;                /*    12     4 */
	void QHashNode(class QHashNode<QString,QConfFile*> *, const class QString  &);

	void QHashNode(class QHashNode<QString,QConfFile*> *, const class QString  &, const class QConfFile *  &);

	bool same_key(class QHashNode<QString,QConfFile*> *, unsigned int, const class QString  &);

	void ~QHashNode(class QHashNode<QString,QConfFile*> *, int);

}; /* size: 16, cachelines: 1 */
   /* last cacheline: 16 bytes */
   /* definitions: 1 */

struct QGlobalStatic<QHash<QString, QConfFile*> > {
	class QHash<QString,QConfFile*> * pointer;       /*     0     4 */
	bool                       destroyed;            /*     4     1 */
	void QGlobalStatic(class QGlobalStatic<QHash<QString, QConfFile*> > *);

	void ~QGlobalStatic(class QGlobalStatic<QHash<QString, QConfFile*> > *, int);

}; /* size: 8, cachelines: 1 */
   /* padding: 3 */
   /* last cacheline: 8 bytes */
   /* definitions: 1 */

struct QVector<QConfFileCustomFormat> {
	union ._126 {
		class QVectorData *        p;                    /*           4 */
		class QVectorTypedData<QConfFileCustomFormat> * d; /*           4 */
	};

private:

	union ._126                (null);               /*     0     4 */
	void QVector(class QVector<QConfFileCustomFormat> *);

	void QVector(class QVector<QConfFileCustomFormat> *, int);

	void QVector(class QVector<QConfFileCustomFormat> *, int, const class QConfFileCustomFormat  &);

	void QVector(class QVector<QConfFileCustomFormat> *, const class QVector<QConfFileCustomFormat>  &);

	void ~QVector(class QVector<QConfFileCustomFormat> *, int);

	class QVector<QConfFileCustomFormat> & operator=(class QVector<QConfFileCustomFormat> *, const class QVector<QConfFileCustomFormat>  &);

	bool operator==(const class QVector<QConfFileCustomFormat>  *, const class QVector<QConfFileCustomFormat>  &);

	bool operator!=(const class QVector<QConfFileCustomFormat>  *, const class QVector<QConfFileCustomFormat>  &);

	int size(const class QVector<QConfFileCustomFormat>  *);

	bool isEmpty(const class QVector<QConfFileCustomFormat>  *);

	void resize(class QVector<QConfFileCustomFormat> *, int);

	int capacity(const class QVector<QConfFileCustomFormat>  *);

	void reserve(class QVector<QConfFileCustomFormat> *, int);

	void squeeze(class QVector<QConfFileCustomFormat> *);

	void detach(class QVector<QConfFileCustomFormat> *);

	bool isDetached(const class QVector<QConfFileCustomFormat>  *);

	void setSharable(class QVector<QConfFileCustomFormat> *, bool);

	class QConfFileCustomFormat * data(class QVector<QConfFileCustomFormat> *);

	const class QConfFileCustomFormat  * data(const class QVector<QConfFileCustomFormat>  *);

	const class QConfFileCustomFormat  * constData(const class QVector<QConfFileCustomFormat>  *);

	void clear(class QVector<QConfFileCustomFormat> *);

	const class QConfFileCustomFormat  & at(const class QVector<QConfFileCustomFormat>  *, int);

	class QConfFileCustomFormat & operator[](class QVector<QConfFileCustomFormat> *, int);

	const class QConfFileCustomFormat  & operator[](const class QVector<QConfFileCustomFormat>  *, int);

	void append(class QVector<QConfFileCustomFormat> *, const class QConfFileCustomFormat  &);

	void prepend(class QVector<QConfFileCustomFormat> *, const class QConfFileCustomFormat  &);

	void insert(class QVector<QConfFileCustomFormat> *, int, const class QConfFileCustomFormat  &);

	void insert(class QVector<QConfFileCustomFormat> *, int, int, const class QConfFileCustomFormat  &);

	void replace(class QVector<QConfFileCustomFormat> *, int, const class QConfFileCustomFormat  &);

	void remove(class QVector<QConfFileCustomFormat> *, int);

	void remove(class QVector<QConfFileCustomFormat> *, int, int);

	class QVector<QConfFileCustomFormat> & fill(class QVector<QConfFileCustomFormat> *, const class QConfFileCustomFormat  &, int);

	int indexOf(const class QVector<QConfFileCustomFormat>  *, const class QConfFileCustomFormat  &, int);

	int lastIndexOf(const class QVector<QConfFileCustomFormat>  *, const class QConfFileCustomFormat  &, int);

	bool contains(const class QVector<QConfFileCustomFormat>  *, const class QConfFileCustomFormat  &);

	int count(const class QVector<QConfFileCustomFormat>  *, const class QConfFileCustomFormat  &);

	class QConfFileCustomFormat * begin(class QVector<QConfFileCustomFormat> *);

	const class QConfFileCustomFormat  * begin(const class QVector<QConfFileCustomFormat>  *);

	const class QConfFileCustomFormat  * constBegin(const class QVector<QConfFileCustomFormat>  *);

	class QConfFileCustomFormat * end(class QVector<QConfFileCustomFormat> *);

	const class QConfFileCustomFormat  * end(const class QVector<QConfFileCustomFormat>  *);

	const class QConfFileCustomFormat  * constEnd(const class QVector<QConfFileCustomFormat>  *);

	class QConfFileCustomFormat * insert(class QVector<QConfFileCustomFormat> *, class QConfFileCustomFormat *, int, const class QConfFileCustomFormat  &);

	class QConfFileCustomFormat * insert(class QVector<QConfFileCustomFormat> *, class QConfFileCustomFormat *, const class QConfFileCustomFormat  &);

	class QConfFileCustomFormat * erase(class QVector<QConfFileCustomFormat> *, class QConfFileCustomFormat *, class QConfFileCustomFormat *);

	class QConfFileCustomFormat * erase(class QVector<QConfFileCustomFormat> *, class QConfFileCustomFormat *);

	int count(const class QVector<QConfFileCustomFormat>  *);

	class QConfFileCustomFormat & first(class QVector<QConfFileCustomFormat> *);

	const class QConfFileCustomFormat  & first(const class QVector<QConfFileCustomFormat>  *);

	class QConfFileCustomFormat & last(class QVector<QConfFileCustomFormat> *);

	const class QConfFileCustomFormat  & last(const class QVector<QConfFileCustomFormat>  *);

	class QVector<QConfFileCustomFormat> mid(const class QVector<QConfFileCustomFormat>  *, int, int);

	class QConfFileCustomFormat value(const class QVector<QConfFileCustomFormat>  *, int);

	class QConfFileCustomFormat value(const class QVector<QConfFileCustomFormat>  *, int, const class QConfFileCustomFormat  &);

	void push_back(class QVector<QConfFileCustomFormat> *, const class QConfFileCustomFormat  &);

	void push_front(class QVector<QConfFileCustomFormat> *, const class QConfFileCustomFormat  &);

	void pop_back(class QVector<QConfFileCustomFormat> *);

	void pop_front(class QVector<QConfFileCustomFormat> *);

	bool empty(const class QVector<QConfFileCustomFormat>  *);

	class QConfFileCustomFormat & front(class QVector<QConfFileCustomFormat> *);

	const class QConfFileCustomFormat  & front(const class QVector<QConfFileCustomFormat>  *);

	class QConfFileCustomFormat & back(class QVector<QConfFileCustomFormat> *);

	const class QConfFileCustomFormat  & back(const class QVector<QConfFileCustomFormat>  *);

	class QVector<QConfFileCustomFormat> & operator+=(class QVector<QConfFileCustomFormat> *, const class QVector<QConfFileCustomFormat>  &);

	class QVector<QConfFileCustomFormat> operator+(const class QVector<QConfFileCustomFormat>  *, const class QVector<QConfFileCustomFormat>  &);

	class QVector<QConfFileCustomFormat> & operator+=(class QVector<QConfFileCustomFormat> *, const class QConfFileCustomFormat  &);

	class QVector<QConfFileCustomFormat> & operator<<(class QVector<QConfFileCustomFormat> *, const class QConfFileCustomFormat  &);

	class QVector<QConfFileCustomFormat> & operator<<(class QVector<QConfFileCustomFormat> *, const class QVector<QConfFileCustomFormat>  &);

	class QList<QConfFileCustomFormat> toList(const class QVector<QConfFileCustomFormat>  *);

	class QVector<QConfFileCustomFormat> fromList(const class QList<QConfFileCustomFormat>  &);

	class QVector<QConfFileCustomFormat> fromStdVector(const class vector<QConfFileCustomFormat,std::allocator<QConfFileCustomFormat> >  &);

	class vector<QConfFileCustomFormat,std::allocator<QConfFileCustomFormat> > toStdVector(const class QVector<QConfFileCustomFormat>  *);

	void detach_helper(class QVector<QConfFileCustomFormat> *);

	class QVectorData * malloc(class QVector<QConfFileCustomFormat> *, int);

	void realloc(class QVector<QConfFileCustomFormat> *, int, int);

	void free(class QVector<QConfFileCustomFormat> *, class QVectorTypedData<QConfFileCustomFormat> *);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QHash<int,QString> {
	union ._115 {
		class QHashData *          d;                    /*           4 */
		class QHashNode<int,QString> * e;                /*           4 */
	};

private:

	union ._115                (null);               /*     0     4 */
	struct const_iterator {
	}; /* size: 0, cachelines: 0 */

	struct iterator {
	}; /* size: 0, cachelines: 0 */

	class QHashNode<int,QString> * concrete(class Node *);

	void QHash(class QHash<int,QString> *);

	void QHash(class QHash<int,QString> *, const class QHash<int,QString>  &);

	void ~QHash(class QHash<int,QString> *, int);

	class QHash<int,QString> & operator=(class QHash<int,QString> *, const class QHash<int,QString>  &);

	bool operator==(const class QHash<int,QString>  *, const class QHash<int,QString>  &);

	bool operator!=(const class QHash<int,QString>  *, const class QHash<int,QString>  &);

	int size(const class QHash<int,QString>  *);

	bool isEmpty(const class QHash<int,QString>  *);

	int capacity(const class QHash<int,QString>  *);

	void reserve(class QHash<int,QString> *, int);

	void squeeze(class QHash<int,QString> *);

	void detach(class QHash<int,QString> *);

	bool isDetached(const class QHash<int,QString>  *);

	void setSharable(class QHash<int,QString> *, bool);

	void clear(class QHash<int,QString> *);

	int remove(class QHash<int,QString> *, const int  &);

	class QString take(class QHash<int,QString> *, const int  &);

	bool contains(const class QHash<int,QString>  *, const int  &);

	const int  key(const class QHash<int,QString>  *, const class QString  &);

	const class QString  value(const class QHash<int,QString>  *, const int  &);

	const class QString  value(const class QHash<int,QString>  *, const int  &, const class QString  &);

	class QString & operator[](class QHash<int,QString> *, const int  &);

	const class QString  operator[](const class QHash<int,QString>  *, const int  &);

	class QList<int> uniqueKeys(const class QHash<int,QString>  *);

	class QList<int> keys(const class QHash<int,QString>  *);

	class QList<int> keys(const class QHash<int,QString>  *, const class QString  &);

	class QList<QString> values(const class QHash<int,QString>  *);

	class QList<QString> values(const class QHash<int,QString>  *, const int  &);

	int count(const class QHash<int,QString>  *, const int  &);

	class iterator begin(class QHash<int,QString> *);

	class const_iterator begin(const class QHash<int,QString>  *);

	class const_iterator constBegin(const class QHash<int,QString>  *);

	class iterator end(class QHash<int,QString> *);

	class const_iterator end(const class QHash<int,QString>  *);

	class const_iterator constEnd(const class QHash<int,QString>  *);

	class iterator erase(class QHash<int,QString> *, class iterator);

	int count(const class QHash<int,QString>  *);

	class iterator find(class QHash<int,QString> *, const int  &);

	class const_iterator find(const class QHash<int,QString>  *, const int  &);

	class const_iterator constFind(const class QHash<int,QString>  *, const int  &);

	class iterator insert(class QHash<int,QString> *, const int  &, const class QString  &);

	class iterator insertMulti(class QHash<int,QString> *, const int  &, const class QString  &);

	class QHash<int,QString> & unite(class QHash<int,QString> *, const class QHash<int,QString>  &);

	bool empty(const class QHash<int,QString>  *);

	void detach_helper(class QHash<int,QString> *);

	void freeData(class QHash<int,QString> *, class QHashData *);

	class QHashNode<int,QString> * * findNode(const class QHash<int,QString>  *, const int  &, uint *);

	class QHashNode<int,QString> * createNode(class QHash<int,QString> *, unsigned int, const int  &, const class QString  &, class QHashNode<int,QString> * *);

	void deleteNode(class QHash<int,QString> *, class QHashNode<int,QString> *);

	void duplicateNode(class Node *, void *);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QCache<QString,QConfFile> {
	struct Node {
	}; /* size: 0, cachelines: 0 */

private:

	class Node *               f;                    /*     0     4 */
	class Node *               l;                    /*     4     4 */
	struct QHash<QString,QCache<QString, QConfFile>::Node> hash; /*     8     4 */
	void *                     unused;               /*    12     4 */
	int                        mx;                   /*    16     4 */
	int                        total;                /*    20     4 */
	void unlink(class QCache<QString,QConfFile> *, class Node &);

	class QConfFile * relink(class QCache<QString,QConfFile> *, const class QString  &);

	void QCache(class QCache<QString,QConfFile> *, const class QCache<QString,QConfFile>  &);

	class QCache<QString,QConfFile> & operator=(class QCache<QString,QConfFile> *, const class QCache<QString,QConfFile>  &);

	void QCache(class QCache<QString,QConfFile> *, int);

	void QCache(class QCache<QString,QConfFile> *, int, int);

	void ~QCache(class QCache<QString,QConfFile> *, int);

	int maxCost(const class QCache<QString,QConfFile>  *);

	void setMaxCost(class QCache<QString,QConfFile> *, int);

	int totalCost(const class QCache<QString,QConfFile>  *);

	int size(const class QCache<QString,QConfFile>  *);

	int count(const class QCache<QString,QConfFile>  *);

	bool isEmpty(const class QCache<QString,QConfFile>  *);

	class QList<QString> keys(const class QCache<QString,QConfFile>  *);

	void clear(class QCache<QString,QConfFile> *);

	bool insert(class QCache<QString,QConfFile> *, const class QString  &, class QConfFile *, int);

	class QConfFile * object(const class QCache<QString,QConfFile>  *, const class QString  &);

	bool contains(const class QCache<QString,QConfFile>  *, const class QString  &);

	class QConfFile * operator[](const class QCache<QString,QConfFile>  *, const class QString  &);

	bool remove(class QCache<QString,QConfFile> *, const class QString  &);

	class QConfFile * take(class QCache<QString,QConfFile> *, const class QString  &);

	void trim(class QCache<QString,QConfFile> *, int);

	class QConfFile * find(const class QCache<QString,QConfFile>  *, const class QString  &);

}; /* size: 24, cachelines: 1 */
   /* last cacheline: 24 bytes */
   /* definitions: 1 */

struct QHash<QString,QConfFile*> {
	union ._115 {
		class QHashData *          d;                    /*           4 */
		class QHashNode<QString,QConfFile*> * e;         /*           4 */
	};

private:

	union ._115                (null);               /*     0     4 */
	struct const_iterator {
	}; /* size: 0, cachelines: 0 */

	struct iterator {
	}; /* size: 0, cachelines: 0 */

	class QHashNode<QString,QConfFile*> * concrete(class Node *);

	void QHash(class QHash<QString,QConfFile*> *);

	void QHash(class QHash<QString,QConfFile*> *, const class QHash<QString,QConfFile*>  &);

	void ~QHash(class QHash<QString,QConfFile*> *, int);

	class QHash<QString,QConfFile*> & operator=(class QHash<QString,QConfFile*> *, const class QHash<QString,QConfFile*>  &);

	bool operator==(const class QHash<QString,QConfFile*>  *, const class QHash<QString,QConfFile*>  &);

	bool operator!=(const class QHash<QString,QConfFile*>  *, const class QHash<QString,QConfFile*>  &);

	int size(const class QHash<QString,QConfFile*>  *);

	bool isEmpty(const class QHash<QString,QConfFile*>  *);

	int capacity(const class QHash<QString,QConfFile*>  *);

	void reserve(class QHash<QString,QConfFile*> *, int);

	void squeeze(class QHash<QString,QConfFile*> *);

	void detach(class QHash<QString,QConfFile*> *);

	bool isDetached(const class QHash<QString,QConfFile*>  *);

	void setSharable(class QHash<QString,QConfFile*> *, bool);

	void clear(class QHash<QString,QConfFile*> *);

	int remove(class QHash<QString,QConfFile*> *, const class QString  &);

	class QConfFile * take(class QHash<QString,QConfFile*> *, const class QString  &);

	bool contains(const class QHash<QString,QConfFile*>  *, const class QString  &);

	const class QString  key(const class QHash<QString,QConfFile*>  *, const class QConfFile *  &);

	const class QConfFile *  value(const class QHash<QString,QConfFile*>  *, const class QString  &);

	const class QConfFile *  value(const class QHash<QString,QConfFile*>  *, const class QString  &, const class QConfFile *  &);

	class QConfFile * & operator[](class QHash<QString,QConfFile*> *, const class QString  &);

	const class QConfFile *  operator[](const class QHash<QString,QConfFile*>  *, const class QString  &);

	class QList<QString> uniqueKeys(const class QHash<QString,QConfFile*>  *);

	class QList<QString> keys(const class QHash<QString,QConfFile*>  *);

	class QList<QString> keys(const class QHash<QString,QConfFile*>  *, const class QConfFile *  &);

	class QList<QConfFile*> values(const class QHash<QString,QConfFile*>  *);

	class QList<QConfFile*> values(const class QHash<QString,QConfFile*>  *, const class QString  &);

	int count(const class QHash<QString,QConfFile*>  *, const class QString  &);

	class iterator begin(class QHash<QString,QConfFile*> *);

	class const_iterator begin(const class QHash<QString,QConfFile*>  *);

	class const_iterator constBegin(const class QHash<QString,QConfFile*>  *);

	class iterator end(class QHash<QString,QConfFile*> *);

	class const_iterator end(const class QHash<QString,QConfFile*>  *);

	class const_iterator constEnd(const class QHash<QString,QConfFile*>  *);

	class iterator erase(class QHash<QString,QConfFile*> *, class iterator);

	int count(const class QHash<QString,QConfFile*>  *);

	class iterator find(class QHash<QString,QConfFile*> *, const class QString  &);

	class const_iterator find(const class QHash<QString,QConfFile*>  *, const class QString  &);

	class const_iterator constFind(const class QHash<QString,QConfFile*>  *, const class QString  &);

	class iterator insert(class QHash<QString,QConfFile*> *, const class QString  &, const class QConfFile *  &);

	class iterator insertMulti(class QHash<QString,QConfFile*> *, const class QString  &, const class QConfFile *  &);

	class QHash<QString,QConfFile*> & unite(class QHash<QString,QConfFile*> *, const class QHash<QString,QConfFile*>  &);

	bool empty(const class QHash<QString,QConfFile*>  *);

	void detach_helper(class QHash<QString,QConfFile*> *);

	void freeData(class QHash<QString,QConfFile*> *, class QHashData *);

	class QHashNode<QString,QConfFile*> * * findNode(const class QHash<QString,QConfFile*>  *, const class QString  &, uint *);

	class QHashNode<QString,QConfFile*> * createNode(class QHash<QString,QConfFile*> *, unsigned int, const class QString  &, const class QConfFile *  &, class QHashNode<QString,QConfFile*> * *);

	void deleteNode(class QHash<QString,QConfFile*> *, class QHashNode<QString,QConfFile*> *);

	void duplicateNode(class Node *, void *);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QConfFileCustomFormat {
	struct QString             extension;            /*     0     4 */
	bool                       (*readFunc)(class QIODevice &, class QMap<QString,QVariant> &); /*     4     4 */
	bool                       (*writeFunc)(class QIODevice &, const class QMap<QString,QVariant>  &); /*     8     4 */
	enum CaseSensitivity       caseSensitivity;      /*    12     4 */
	void QConfFileCustomFormat(class QConfFileCustomFormat *);

	void QConfFileCustomFormat(class QConfFileCustomFormat *, const class QConfFileCustomFormat  &);

	void ~QConfFileCustomFormat(class QConfFileCustomFormat *, int);

}; /* size: 16, cachelines: 1 */
   /* last cacheline: 16 bytes */
   /* definitions: 1 */

struct QFlags<QDir::SortFlag> {
private:

	int                        i;                    /*     0     4 */
	void QFlags(class QFlags<QDir::SortFlag> *, const class QFlags<QDir::SortFlag>  &);

	void QFlags(class QFlags<QDir::SortFlag> *, enum SortFlag);

	void QFlags(class QFlags<QDir::SortFlag> *, void * *);

	void QFlags(class QFlags<QDir::SortFlag> *, class QFlag);

	class QFlags<QDir::SortFlag> & operator=(class QFlags<QDir::SortFlag> *, const class QFlags<QDir::SortFlag>  &);

	class QFlags<QDir::SortFlag> & operator&=(class QFlags<QDir::SortFlag> *, int);

	class QFlags<QDir::SortFlag> & operator&=(class QFlags<QDir::SortFlag> *, unsigned int);

	class QFlags<QDir::SortFlag> & operator|=(class QFlags<QDir::SortFlag> *, class QFlags<QDir::SortFlag>);

	class QFlags<QDir::SortFlag> & operator|=(class QFlags<QDir::SortFlag> *, enum SortFlag);

	class QFlags<QDir::SortFlag> & operator^=(class QFlags<QDir::SortFlag> *, class QFlags<QDir::SortFlag>);

	class QFlags<QDir::SortFlag> & operator^=(class QFlags<QDir::SortFlag> *, enum SortFlag);

	int operator int(const class QFlags<QDir::SortFlag>  *);

	class QFlags<QDir::SortFlag> operator|(const class QFlags<QDir::SortFlag>  *, class QFlags<QDir::SortFlag>);

	class QFlags<QDir::SortFlag> operator|(const class QFlags<QDir::SortFlag>  *, enum SortFlag);

	class QFlags<QDir::SortFlag> operator^(const class QFlags<QDir::SortFlag>  *, class QFlags<QDir::SortFlag>);

	class QFlags<QDir::SortFlag> operator^(const class QFlags<QDir::SortFlag>  *, enum SortFlag);

	class QFlags<QDir::SortFlag> operator&(const class QFlags<QDir::SortFlag>  *, int);

	class QFlags<QDir::SortFlag> operator&(const class QFlags<QDir::SortFlag>  *, unsigned int);

	class QFlags<QDir::SortFlag> operator&(const class QFlags<QDir::SortFlag>  *, enum SortFlag);

	class QFlags<QDir::SortFlag> operator~(const class QFlags<QDir::SortFlag>  *);

	bool operator!(const class QFlags<QDir::SortFlag>  *);

	bool testFlag(const class QFlags<QDir::SortFlag>  *, enum SortFlag);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QFlags<QDir::Filter> {
private:

	int                        i;                    /*     0     4 */
	void QFlags(class QFlags<QDir::Filter> *, const class QFlags<QDir::Filter>  &);

	void QFlags(class QFlags<QDir::Filter> *, enum Filter);

	void QFlags(class QFlags<QDir::Filter> *, void * *);

	void QFlags(class QFlags<QDir::Filter> *, class QFlag);

	class QFlags<QDir::Filter> & operator=(class QFlags<QDir::Filter> *, const class QFlags<QDir::Filter>  &);

	class QFlags<QDir::Filter> & operator&=(class QFlags<QDir::Filter> *, int);

	class QFlags<QDir::Filter> & operator&=(class QFlags<QDir::Filter> *, unsigned int);

	class QFlags<QDir::Filter> & operator|=(class QFlags<QDir::Filter> *, class QFlags<QDir::Filter>);

	class QFlags<QDir::Filter> & operator|=(class QFlags<QDir::Filter> *, enum Filter);

	class QFlags<QDir::Filter> & operator^=(class QFlags<QDir::Filter> *, class QFlags<QDir::Filter>);

	class QFlags<QDir::Filter> & operator^=(class QFlags<QDir::Filter> *, enum Filter);

	int operator int(const class QFlags<QDir::Filter>  *);

	class QFlags<QDir::Filter> operator|(const class QFlags<QDir::Filter>  *, class QFlags<QDir::Filter>);

	class QFlags<QDir::Filter> operator|(const class QFlags<QDir::Filter>  *, enum Filter);

	class QFlags<QDir::Filter> operator^(const class QFlags<QDir::Filter>  *, class QFlags<QDir::Filter>);

	class QFlags<QDir::Filter> operator^(const class QFlags<QDir::Filter>  *, enum Filter);

	class QFlags<QDir::Filter> operator&(const class QFlags<QDir::Filter>  *, int);

	class QFlags<QDir::Filter> operator&(const class QFlags<QDir::Filter>  *, unsigned int);

	class QFlags<QDir::Filter> operator&(const class QFlags<QDir::Filter>  *, enum Filter);

	class QFlags<QDir::Filter> operator~(const class QFlags<QDir::Filter>  *);

	bool operator!(const class QFlags<QDir::Filter>  *);

	bool testFlag(const class QFlags<QDir::Filter>  *, enum Filter);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QList<QFileInfo> {
	union ._105 {
		struct QListData           p;                    /*           4 */
		class Data *               d;                    /*           4 */
	};

private:

	union ._105                (null);               /*     0     4 */
	struct Node {
	}; /* size: 0, cachelines: 0 */

	struct const_iterator {
	}; /* size: 0, cachelines: 0 */

	struct iterator {
	}; /* size: 0, cachelines: 0 */

	void QList(class QList<QFileInfo> *);

	void QList(class QList<QFileInfo> *, const class QList<QFileInfo>  &);

	void ~QList(class QList<QFileInfo> *, int);

	class QList<QFileInfo> & operator=(class QList<QFileInfo> *, const class QList<QFileInfo>  &);

	bool operator==(const class QList<QFileInfo>  *, const class QList<QFileInfo>  &);

	bool operator!=(const class QList<QFileInfo>  *, const class QList<QFileInfo>  &);

	int size(const class QList<QFileInfo>  *);

	void detach(class QList<QFileInfo> *);

	bool isDetached(const class QList<QFileInfo>  *);

	void setSharable(class QList<QFileInfo> *, bool);

	bool isEmpty(const class QList<QFileInfo>  *);

	void clear(class QList<QFileInfo> *);

	const class QFileInfo  & at(const class QList<QFileInfo>  *, int);

	const class QFileInfo  & operator[](const class QList<QFileInfo>  *, int);

	class QFileInfo & operator[](class QList<QFileInfo> *, int);

	void append(class QList<QFileInfo> *, const class QFileInfo  &);

	void prepend(class QList<QFileInfo> *, const class QFileInfo  &);

	void insert(class QList<QFileInfo> *, int, const class QFileInfo  &);

	void replace(class QList<QFileInfo> *, int, const class QFileInfo  &);

	void removeAt(class QList<QFileInfo> *, int);

	int removeAll(class QList<QFileInfo> *, const class QFileInfo  &);

	class QFileInfo takeAt(class QList<QFileInfo> *, int);

	class QFileInfo takeFirst(class QList<QFileInfo> *);

	class QFileInfo takeLast(class QList<QFileInfo> *);

	void move(class QList<QFileInfo> *, int, int);

	void swap(class QList<QFileInfo> *, int, int);

	int indexOf(const class QList<QFileInfo>  *, const class QFileInfo  &, int);

	int lastIndexOf(const class QList<QFileInfo>  *, const class QFileInfo  &, int);

	class QBool contains(const class QList<QFileInfo>  *, const class QFileInfo  &);

	int count(const class QList<QFileInfo>  *, const class QFileInfo  &);

	class iterator begin(class QList<QFileInfo> *);

	class const_iterator begin(const class QList<QFileInfo>  *);

	class const_iterator constBegin(const class QList<QFileInfo>  *);

	class iterator end(class QList<QFileInfo> *);

	class const_iterator end(const class QList<QFileInfo>  *);

	class const_iterator constEnd(const class QList<QFileInfo>  *);

	class iterator insert(class QList<QFileInfo> *, class iterator, const class QFileInfo  &);

	class iterator erase(class QList<QFileInfo> *, class iterator);

	class iterator erase(class QList<QFileInfo> *, class iterator, class iterator);

	int count(const class QList<QFileInfo>  *);

	class QFileInfo & first(class QList<QFileInfo> *);

	const class QFileInfo  & first(const class QList<QFileInfo>  *);

	class QFileInfo & last(class QList<QFileInfo> *);

	const class QFileInfo  & last(const class QList<QFileInfo>  *);

	void removeFirst(class QList<QFileInfo> *);

	void removeLast(class QList<QFileInfo> *);

	class QList<QFileInfo> mid(const class QList<QFileInfo>  *, int, int);

	class QFileInfo value(const class QList<QFileInfo>  *, int);

	class QFileInfo value(const class QList<QFileInfo>  *, int, const class QFileInfo  &);

	void push_back(class QList<QFileInfo> *, const class QFileInfo  &);

	void push_front(class QList<QFileInfo> *, const class QFileInfo  &);

	class QFileInfo & front(class QList<QFileInfo> *);

	const class QFileInfo  & front(const class QList<QFileInfo>  *);

	class QFileInfo & back(class QList<QFileInfo> *);

	const class QFileInfo  & back(const class QList<QFileInfo>  *);

	void pop_front(class QList<QFileInfo> *);

	void pop_back(class QList<QFileInfo> *);

	bool empty(const class QList<QFileInfo>  *);

	class iterator remove(class QList<QFileInfo> *, class iterator);

	int remove(class QList<QFileInfo> *, const class QFileInfo  &);

	int findIndex(const class QList<QFileInfo>  *, const class QFileInfo  &);

	class iterator find(class QList<QFileInfo> *, const class QFileInfo  &);

	class const_iterator find(const class QList<QFileInfo>  *, const class QFileInfo  &);

	class iterator find(class QList<QFileInfo> *, class iterator, const class QFileInfo  &);

	class const_iterator find(const class QList<QFileInfo>  *, class const_iterator, const class QFileInfo  &);

	class QList<QFileInfo> & operator+=(class QList<QFileInfo> *, const class QList<QFileInfo>  &);

	class QList<QFileInfo> operator+(const class QList<QFileInfo>  *, const class QList<QFileInfo>  &);

	class QList<QFileInfo> & operator+=(class QList<QFileInfo> *, const class QFileInfo  &);

	class QList<QFileInfo> & operator<<(class QList<QFileInfo> *, const class QFileInfo  &);

	class QList<QFileInfo> & operator<<(class QList<QFileInfo> *, const class QList<QFileInfo>  &);

	class QVector<QFileInfo> toVector(const class QList<QFileInfo>  *);

	class QSet<QFileInfo> toSet(const class QList<QFileInfo>  *);

	class QList<QFileInfo> fromVector(const class QVector<QFileInfo>  &);

	class QList<QFileInfo> fromSet(const class QSet<QFileInfo>  &);

	class QList<QFileInfo> fromStdList(const class list<QFileInfo,std::allocator<QFileInfo> >  &);

	class list<QFileInfo,std::allocator<QFileInfo> > toStdList(const class QList<QFileInfo>  *);

	void detach_helper(class QList<QFileInfo> *);

	void free(class QList<QFileInfo> *, class Data *);

	void node_construct(class QList<QFileInfo> *, class Node *, const class QFileInfo  &);

	void node_destruct(class QList<QFileInfo> *, class Node *);

	void node_copy(class QList<QFileInfo> *, class Node *, class Node *, class Node *);

	void node_destruct(class QList<QFileInfo> *, class Node *, class Node *);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QDir {
	enum Filter {
		Dirs = 1,
		Files = 2,
		Drives = 4,
		NoSymLinks = 8,
		AllEntries = 7,
		TypeMask = 15,
		All = 7,
		Readable = 16,
		Writable = 32,
		Executable = 64,
		PermissionMask = 112,
		RWEMask = 112,
		Modified = 128,
		Hidden = 256,
		System = 512,
		AccessMask = 1008,
		AllDirs = 1024,
		CaseSensitive = 2048,
		NoDotAndDotDot = 4096,
		NoFilter = 4294967295,
		DefaultFilter = 4294967295,
	};

	enum SortFlag {
		Name = 0,
		Time = 1,
		Size = 2,
		Unsorted = 3,
		SortByMask = 3,
		DirsFirst = 4,
		Reversed = 8,
		IgnoreCase = 16,
		DirsLast = 32,
		LocaleAware = 64,
		Type = 128,
		NoSort = 4294967295,
		DefaultSort = 4294967295,
	};

protected:

	class QDirPrivate *        d_ptr;                /*     0     4 */
private:

	class QDirPrivate * d_func(class QDir *);

	const class QDirPrivate  * d_func(const class QDir  *);

	void QDir(class QDir *, const class QDir  &);

	void QDir(class QDir *, const class QString  &);

	void QDir(class QDir *, const class QString  &, const class QString  &, class QFlags<QDir::SortFlag>, class QFlags<QDir::Filter>);

	void ~QDir(class QDir *, int);

	class QDir & operator=(class QDir *, const class QDir  &);

	class QDir & operator=(class QDir *, const class QString  &);

	void setPath(class QDir *, const class QString  &);

	class QString path(const class QDir  *);

	class QString absolutePath(const class QDir  *);

	class QString canonicalPath(const class QDir  *);

	void addResourceSearchPath(const class QString  &);

	class QString dirName(const class QDir  *);

	class QString filePath(const class QDir  *, const class QString  &);

	class QString absoluteFilePath(const class QDir  *, const class QString  &);

	class QString relativeFilePath(const class QDir  *, const class QString  &);

	class QString convertSeparators(const class QString  &);

	class QString toNativeSeparators(const class QString  &);

	class QString fromNativeSeparators(const class QString  &);

	bool cd(class QDir *, const class QString  &);

	bool cdUp(class QDir *);

	class QStringList nameFilters(const class QDir  *);

	void setNameFilters(class QDir *, const class QStringList  &);

	class QFlags<QDir::Filter> filter(const class QDir  *);

	void setFilter(class QDir *, class QFlags<QDir::Filter>);

	class QFlags<QDir::SortFlag> sorting(const class QDir  *);

	void setSorting(class QDir *, class QFlags<QDir::SortFlag>);

	uint count(const class QDir  *);

	class QString operator[](const class QDir  *, int);

	class QStringList nameFiltersFromString(const class QString  &);

	class QStringList entryList(const class QDir  *, class QFlags<QDir::Filter>, class QFlags<QDir::SortFlag>);

	class QStringList entryList(const class QDir  *, const class QStringList  &, class QFlags<QDir::Filter>, class QFlags<QDir::SortFlag>);

	QFileInfoList entryInfoList(const class QDir  *, class QFlags<QDir::Filter>, class QFlags<QDir::SortFlag>);

	QFileInfoList entryInfoList(const class QDir  *, const class QStringList  &, class QFlags<QDir::Filter>, class QFlags<QDir::SortFlag>);

	bool mkdir(const class QDir  *, const class QString  &);

	bool rmdir(const class QDir  *, const class QString  &);

	bool mkpath(const class QDir  *, const class QString  &);

	bool rmpath(const class QDir  *, const class QString  &);

	bool isReadable(const class QDir  *);

	bool exists(const class QDir  *);

	bool isRoot(const class QDir  *);

	bool isRelativePath(const class QString  &);

	bool isAbsolutePath(const class QString  &);

	bool isRelative(const class QDir  *);

	bool isAbsolute(const class QDir  *);

	bool makeAbsolute(class QDir *);

	bool operator==(const class QDir  *, const class QDir  &);

	bool operator!=(const class QDir  *, const class QDir  &);

	bool remove(class QDir *, const class QString  &);

	bool rename(class QDir *, const class QString  &, const class QString  &);

	bool exists(const class QDir  *, const class QString  &);

	QFileInfoList drives(void);

	class QChar separator(void);

	bool setCurrent(const class QString  &);

	class QDir current(void);

	class QString currentPath(void);

	class QDir home(void);

	class QString homePath(void);

	class QDir root(void);

	class QString rootPath(void);

	class QDir temp(void);

	class QString tempPath(void);

	bool match(const class QStringList  &, const class QString  &);

	bool match(const class QString  &, const class QString  &);

	class QString cleanPath(const class QString  &);

	void refresh(const class QDir  *);

	class QString absPath(const class QDir  *);

	class QString absFilePath(const class QDir  *, const class QString  &, bool);

	bool matchAllDirs(const class QDir  *);

	void setMatchAllDirs(class QDir *, bool);

	class QStringList entryList(const class QDir  *, const class QString  &, class QFlags<QDir::Filter>, class QFlags<QDir::SortFlag>);

	QFileInfoList entryInfoList(const class QDir  *, const class QString  &, class QFlags<QDir::Filter>, class QFlags<QDir::SortFlag>);

	class QString nameFilter(const class QDir  *);

	void setNameFilter(class QDir *, const class QString  &);

	bool mkdir(const class QDir  *, const class QString  &, bool);

	bool rmdir(const class QDir  *, const class QString  &, bool);

	void convertToAbs(class QDir *);

	class QString currentDirPath(void);

	class QString homeDirPath(void);

	class QString rootDirPath(void);

	class QString cleanDirPath(const class QString  &);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QFlags<QFileInfo::Permission> {
private:

	int                        i;                    /*     0     4 */
	void QFlags(class QFlags<QFileInfo::Permission> *, const class QFlags<QFileInfo::Permission>  &);

	void QFlags(class QFlags<QFileInfo::Permission> *, enum Permission);

	void QFlags(class QFlags<QFileInfo::Permission> *, void * *);

	void QFlags(class QFlags<QFileInfo::Permission> *, class QFlag);

	class QFlags<QFileInfo::Permission> & operator=(class QFlags<QFileInfo::Permission> *, const class QFlags<QFileInfo::Permission>  &);

	class QFlags<QFileInfo::Permission> & operator&=(class QFlags<QFileInfo::Permission> *, int);

	class QFlags<QFileInfo::Permission> & operator&=(class QFlags<QFileInfo::Permission> *, unsigned int);

	class QFlags<QFileInfo::Permission> & operator|=(class QFlags<QFileInfo::Permission> *, class QFlags<QFileInfo::Permission>);

	class QFlags<QFileInfo::Permission> & operator|=(class QFlags<QFileInfo::Permission> *, enum Permission);

	class QFlags<QFileInfo::Permission> & operator^=(class QFlags<QFileInfo::Permission> *, class QFlags<QFileInfo::Permission>);

	class QFlags<QFileInfo::Permission> & operator^=(class QFlags<QFileInfo::Permission> *, enum Permission);

	int operator int(const class QFlags<QFileInfo::Permission>  *);

	class QFlags<QFileInfo::Permission> operator|(const class QFlags<QFileInfo::Permission>  *, class QFlags<QFileInfo::Permission>);

	class QFlags<QFileInfo::Permission> operator|(const class QFlags<QFileInfo::Permission>  *, enum Permission);

	class QFlags<QFileInfo::Permission> operator^(const class QFlags<QFileInfo::Permission>  *, class QFlags<QFileInfo::Permission>);

	class QFlags<QFileInfo::Permission> operator^(const class QFlags<QFileInfo::Permission>  *, enum Permission);

	class QFlags<QFileInfo::Permission> operator&(const class QFlags<QFileInfo::Permission>  *, int);

	class QFlags<QFileInfo::Permission> operator&(const class QFlags<QFileInfo::Permission>  *, unsigned int);

	class QFlags<QFileInfo::Permission> operator&(const class QFlags<QFileInfo::Permission>  *, enum Permission);

	class QFlags<QFileInfo::Permission> operator~(const class QFlags<QFileInfo::Permission>  *);

	bool operator!(const class QFlags<QFileInfo::Permission>  *);

	bool testFlag(const class QFlags<QFileInfo::Permission>  *, enum Permission);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QFileInfo {
	enum Permission {
		ReadOwner = 16384,
		WriteOwner = 8192,
		ExeOwner = 4096,
		ReadUser = 1024,
		WriteUser = 512,
		ExeUser = 256,
		ReadGroup = 64,
		WriteGroup = 32,
		ExeGroup = 16,
		ReadOther = 4,
		WriteOther = 2,
		ExeOther = 1,
	};

protected:

	class QFileInfoPrivate *   d_ptr;                /*     0     4 */
	void QFileInfo(class QFileInfo *);

	void QFileInfo(class QFileInfo *, const class QString  &);

	void QFileInfo(class QFileInfo *, const class QFile  &);

	void QFileInfo(class QFileInfo *, const class QDir  &, const class QString  &);

	void QFileInfo(class QFileInfo *, const class QFileInfo  &);

	void ~QFileInfo(class QFileInfo *, int);

	class QFileInfo & operator=(class QFileInfo *, const class QFileInfo  &);

	bool operator==(class QFileInfo *, const class QFileInfo  &);

	bool operator==(const class QFileInfo  *, const class QFileInfo  &);

	bool operator!=(class QFileInfo *, const class QFileInfo  &);

	bool operator!=(const class QFileInfo  *, const class QFileInfo  &);

	void setFile(class QFileInfo *, const class QString  &);

	void setFile(class QFileInfo *, const class QFile  &);

	void setFile(class QFileInfo *, const class QDir  &, const class QString  &);

	bool exists(const class QFileInfo  *);

	void refresh(class QFileInfo *);

	class QString filePath(const class QFileInfo  *);

	class QString absoluteFilePath(const class QFileInfo  *);

	class QString canonicalFilePath(const class QFileInfo  *);

	class QString fileName(const class QFileInfo  *);

	class QString baseName(const class QFileInfo  *);

	class QString completeBaseName(const class QFileInfo  *);

	class QString suffix(const class QFileInfo  *);

	class QString completeSuffix(const class QFileInfo  *);

	class QString path(const class QFileInfo  *);

	class QString absolutePath(const class QFileInfo  *);

	class QString canonicalPath(const class QFileInfo  *);

	class QDir dir(const class QFileInfo  *);

	class QDir absoluteDir(const class QFileInfo  *);

	bool isReadable(const class QFileInfo  *);

	bool isWritable(const class QFileInfo  *);

	bool isExecutable(const class QFileInfo  *);

	bool isHidden(const class QFileInfo  *);

	bool isRelative(const class QFileInfo  *);

	bool isAbsolute(const class QFileInfo  *);

	bool makeAbsolute(class QFileInfo *);

	bool isFile(const class QFileInfo  *);

	bool isDir(const class QFileInfo  *);

	bool isSymLink(const class QFileInfo  *);

	bool isRoot(const class QFileInfo  *);

	class QString readLink(const class QFileInfo  *);

	class QString symLinkTarget(const class QFileInfo  *);

	class QString owner(const class QFileInfo  *);

	uint ownerId(const class QFileInfo  *);

	class QString group(const class QFileInfo  *);

	uint groupId(const class QFileInfo  *);

	bool permission(const class QFileInfo  *, class QFlags<QFile::Permission>);

	class QFlags<QFile::Permission> permissions(const class QFileInfo  *);

	qint64 size(const class QFileInfo  *);

	class QDateTime created(const class QFileInfo  *);

	class QDateTime lastModified(const class QFileInfo  *);

	class QDateTime lastRead(const class QFileInfo  *);

	void detach(class QFileInfo *);

	bool caching(const class QFileInfo  *);

	void setCaching(class QFileInfo *, bool);

	class QString baseName(class QFileInfo *, bool);

	class QString extension(const class QFileInfo  *, bool);

	class QString absFilePath(const class QFileInfo  *);

	class QString dirPath(const class QFileInfo  *, bool);

	class QDir dir(const class QFileInfo  *, bool);

	bool convertToAbs(class QFileInfo *);

	bool permission(const class QFileInfo  *, class QFlags<QFileInfo::Permission>);

private:

	class QFileInfoPrivate * d_func(class QFileInfo *);

	const class QFileInfoPrivate  * d_func(const class QFileInfo  *);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QFlags<QFile::Permission> {
private:

	int                        i;                    /*     0     4 */
	void QFlags(class QFlags<QFile::Permission> *, const class QFlags<QFile::Permission>  &);

	void QFlags(class QFlags<QFile::Permission> *, enum Permission);

	void QFlags(class QFlags<QFile::Permission> *, void * *);

	void QFlags(class QFlags<QFile::Permission> *, class QFlag);

	class QFlags<QFile::Permission> & operator=(class QFlags<QFile::Permission> *, const class QFlags<QFile::Permission>  &);

	class QFlags<QFile::Permission> & operator&=(class QFlags<QFile::Permission> *, int);

	class QFlags<QFile::Permission> & operator&=(class QFlags<QFile::Permission> *, unsigned int);

	class QFlags<QFile::Permission> & operator|=(class QFlags<QFile::Permission> *, class QFlags<QFile::Permission>);

	class QFlags<QFile::Permission> & operator|=(class QFlags<QFile::Permission> *, enum Permission);

	class QFlags<QFile::Permission> & operator^=(class QFlags<QFile::Permission> *, class QFlags<QFile::Permission>);

	class QFlags<QFile::Permission> & operator^=(class QFlags<QFile::Permission> *, enum Permission);

	int operator int(const class QFlags<QFile::Permission>  *);

	class QFlags<QFile::Permission> operator|(const class QFlags<QFile::Permission>  *, class QFlags<QFile::Permission>);

	class QFlags<QFile::Permission> operator|(const class QFlags<QFile::Permission>  *, enum Permission);

	class QFlags<QFile::Permission> operator^(const class QFlags<QFile::Permission>  *, class QFlags<QFile::Permission>);

	class QFlags<QFile::Permission> operator^(const class QFlags<QFile::Permission>  *, enum Permission);

	class QFlags<QFile::Permission> operator&(const class QFlags<QFile::Permission>  *, int);

	class QFlags<QFile::Permission> operator&(const class QFlags<QFile::Permission>  *, unsigned int);

	class QFlags<QFile::Permission> operator&(const class QFlags<QFile::Permission>  *, enum Permission);

	class QFlags<QFile::Permission> operator~(const class QFlags<QFile::Permission>  *);

	bool operator!(const class QFlags<QFile::Permission>  *);

	bool testFlag(const class QFlags<QFile::Permission>  *, enum Permission);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QStack<QSettingsGroup> : public QVector<QSettingsGroup> {
public:

	struct QVector<QSettingsGroup> (null);           /*     0     4 */
	void QStack(class QStack<QSettingsGroup> *);

	void ~QStack(class QStack<QSettingsGroup> *, int);

	void push(class QStack<QSettingsGroup> *, const class QSettingsGroup  &);

	class QSettingsGroup pop(class QStack<QSettingsGroup> *);

	class QSettingsGroup & top(class QStack<QSettingsGroup> *);

	const class QSettingsGroup  & top(const class QStack<QSettingsGroup>  *);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QVectorTypedData<QSettingsGroup> {
	struct QBasicAtomic        ref;                  /*     0     4 */
	int                        alloc;                /*     4     4 */
	int                        size;                 /*     8     4 */
	uint                       sharable:1;           /*    12     4 */

	/* XXX 31 bits hole, try to pack */

	class QSettingsGroup       array[1];             /*    16    12 */
}; /* size: 28, cachelines: 1 */
   /* bit holes: 1, sum bit holes: 31 bits */
   /* last cacheline: 28 bytes */
   /* definitions: 1 */

struct QVector<QSettingsGroup> {
	union ._126 {
		class QVectorData *        p;                    /*           4 */
		class QVectorTypedData<QSettingsGroup> * d;      /*           4 */
	};

private:

	union ._126                (null);               /*     0     4 */
	void QVector(class QVector<QSettingsGroup> *);

	void QVector(class QVector<QSettingsGroup> *, int);

	void QVector(class QVector<QSettingsGroup> *, int, const class QSettingsGroup  &);

	void QVector(class QVector<QSettingsGroup> *, const class QVector<QSettingsGroup>  &);

	void ~QVector(class QVector<QSettingsGroup> *, int);

	class QVector<QSettingsGroup> & operator=(class QVector<QSettingsGroup> *, const class QVector<QSettingsGroup>  &);

	bool operator==(const class QVector<QSettingsGroup>  *, const class QVector<QSettingsGroup>  &);

	bool operator!=(const class QVector<QSettingsGroup>  *, const class QVector<QSettingsGroup>  &);

	int size(const class QVector<QSettingsGroup>  *);

	bool isEmpty(const class QVector<QSettingsGroup>  *);

	void resize(class QVector<QSettingsGroup> *, int);

	int capacity(const class QVector<QSettingsGroup>  *);

	void reserve(class QVector<QSettingsGroup> *, int);

	void squeeze(class QVector<QSettingsGroup> *);

	void detach(class QVector<QSettingsGroup> *);

	bool isDetached(const class QVector<QSettingsGroup>  *);

	void setSharable(class QVector<QSettingsGroup> *, bool);

	class QSettingsGroup * data(class QVector<QSettingsGroup> *);

	const class QSettingsGroup  * data(const class QVector<QSettingsGroup>  *);

	const class QSettingsGroup  * constData(const class QVector<QSettingsGroup>  *);

	void clear(class QVector<QSettingsGroup> *);

	const class QSettingsGroup  & at(const class QVector<QSettingsGroup>  *, int);

	class QSettingsGroup & operator[](class QVector<QSettingsGroup> *, int);

	const class QSettingsGroup  & operator[](const class QVector<QSettingsGroup>  *, int);

	void append(class QVector<QSettingsGroup> *, const class QSettingsGroup  &);

	void prepend(class QVector<QSettingsGroup> *, const class QSettingsGroup  &);

	void insert(class QVector<QSettingsGroup> *, int, const class QSettingsGroup  &);

	void insert(class QVector<QSettingsGroup> *, int, int, const class QSettingsGroup  &);

	void replace(class QVector<QSettingsGroup> *, int, const class QSettingsGroup  &);

	void remove(class QVector<QSettingsGroup> *, int);

	void remove(class QVector<QSettingsGroup> *, int, int);

	class QVector<QSettingsGroup> & fill(class QVector<QSettingsGroup> *, const class QSettingsGroup  &, int);

	int indexOf(const class QVector<QSettingsGroup>  *, const class QSettingsGroup  &, int);

	int lastIndexOf(const class QVector<QSettingsGroup>  *, const class QSettingsGroup  &, int);

	bool contains(const class QVector<QSettingsGroup>  *, const class QSettingsGroup  &);

	int count(const class QVector<QSettingsGroup>  *, const class QSettingsGroup  &);

	class QSettingsGroup * begin(class QVector<QSettingsGroup> *);

	const class QSettingsGroup  * begin(const class QVector<QSettingsGroup>  *);

	const class QSettingsGroup  * constBegin(const class QVector<QSettingsGroup>  *);

	class QSettingsGroup * end(class QVector<QSettingsGroup> *);

	const class QSettingsGroup  * end(const class QVector<QSettingsGroup>  *);

	const class QSettingsGroup  * constEnd(const class QVector<QSettingsGroup>  *);

	class QSettingsGroup * insert(class QVector<QSettingsGroup> *, class QSettingsGroup *, int, const class QSettingsGroup  &);

	class QSettingsGroup * insert(class QVector<QSettingsGroup> *, class QSettingsGroup *, const class QSettingsGroup  &);

	class QSettingsGroup * erase(class QVector<QSettingsGroup> *, class QSettingsGroup *, class QSettingsGroup *);

	class QSettingsGroup * erase(class QVector<QSettingsGroup> *, class QSettingsGroup *);

	int count(const class QVector<QSettingsGroup>  *);

	class QSettingsGroup & first(class QVector<QSettingsGroup> *);

	const class QSettingsGroup  & first(const class QVector<QSettingsGroup>  *);

	class QSettingsGroup & last(class QVector<QSettingsGroup> *);

	const class QSettingsGroup  & last(const class QVector<QSettingsGroup>  *);

	class QVector<QSettingsGroup> mid(const class QVector<QSettingsGroup>  *, int, int);

	class QSettingsGroup value(const class QVector<QSettingsGroup>  *, int);

	class QSettingsGroup value(const class QVector<QSettingsGroup>  *, int, const class QSettingsGroup  &);

	void push_back(class QVector<QSettingsGroup> *, const class QSettingsGroup  &);

	void push_front(class QVector<QSettingsGroup> *, const class QSettingsGroup  &);

	void pop_back(class QVector<QSettingsGroup> *);

	void pop_front(class QVector<QSettingsGroup> *);

	bool empty(const class QVector<QSettingsGroup>  *);

	class QSettingsGroup & front(class QVector<QSettingsGroup> *);

	const class QSettingsGroup  & front(const class QVector<QSettingsGroup>  *);

	class QSettingsGroup & back(class QVector<QSettingsGroup> *);

	const class QSettingsGroup  & back(const class QVector<QSettingsGroup>  *);

	class QVector<QSettingsGroup> & operator+=(class QVector<QSettingsGroup> *, const class QVector<QSettingsGroup>  &);

	class QVector<QSettingsGroup> operator+(const class QVector<QSettingsGroup>  *, const class QVector<QSettingsGroup>  &);

	class QVector<QSettingsGroup> & operator+=(class QVector<QSettingsGroup> *, const class QSettingsGroup  &);

	class QVector<QSettingsGroup> & operator<<(class QVector<QSettingsGroup> *, const class QSettingsGroup  &);

	class QVector<QSettingsGroup> & operator<<(class QVector<QSettingsGroup> *, const class QVector<QSettingsGroup>  &);

	class QList<QSettingsGroup> toList(const class QVector<QSettingsGroup>  *);

	class QVector<QSettingsGroup> fromList(const class QList<QSettingsGroup>  &);

	class QVector<QSettingsGroup> fromStdVector(const class vector<QSettingsGroup,std::allocator<QSettingsGroup> >  &);

	class vector<QSettingsGroup,std::allocator<QSettingsGroup> > toStdVector(const class QVector<QSettingsGroup>  *);

	void detach_helper(class QVector<QSettingsGroup> *);

	class QVectorData * malloc(class QVector<QSettingsGroup> *, int);

	void realloc(class QVector<QSettingsGroup> *, int, int);

	void free(class QVector<QSettingsGroup> *, class QVectorTypedData<QSettingsGroup> *);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QSettingsPrivate : public QObjectPrivate {
	enum ChildSpec {
		AllKeys = 0,
		ChildKeys = 1,
		ChildGroups = 2,
	};

public:

	struct QObjectPrivate      (null);               /*     0     0 */

	/* XXX 56 bytes hole, try to pack */
protected:


	struct QStack<QSettingsGroup> groupStack;        /*    56     4 */
	struct QString             groupPrefix;          /*    60     4 */
	/* --- cacheline 1 boundary (64 bytes) --- */
	int                        spec;                 /*    64     4 */
	bool                       fallbacks;            /*    68     1 */
	bool                       pendingChanges;       /*    69     1 */

	/* XXX 2 bytes hole, try to pack */

	enum Status                status;               /*    72     4 */
	void QSettingsPrivate(class QSettingsPrivate *, const class QSettingsPrivate  &);

private:

	class QSettings * q_func(class QSettingsPrivate *);

	const class QSettings  * q_func(const class QSettingsPrivate  *);

	void QSettingsPrivate(class QSettingsPrivate *);

	void ~QSettingsPrivate(class QSettingsPrivate *, int);

	void remove(class QSettingsPrivate *, const class QString  &);

	void set(class QSettingsPrivate *, const class QString  &, const class QVariant  &);

	bool get(const class QSettingsPrivate  *, const class QString  &, class QVariant *);

	class QStringList children(const class QSettingsPrivate  *, const class QString  &, enum ChildSpec);

	void clear(class QSettingsPrivate *);

	void sync(class QSettingsPrivate *);

	void flush(class QSettingsPrivate *);

	bool isWritable(const class QSettingsPrivate  *);

	class QString fileName(const class QSettingsPrivate  *);

	class QString actualKey(const class QSettingsPrivate  *, const class QString  &);

	void beginGroupOrArray(class QSettingsPrivate *, const class QSettingsGroup  &);

	void setStatus(const class QSettingsPrivate  *, enum Status);

	void requestUpdate(class QSettingsPrivate *);

	void update(class QSettingsPrivate *);

	class QString normalizedKey(const class QString  &);

	class QSettingsPrivate * create(enum Format, enum Scope, const class QString  &, const class QString  &);

	class QSettingsPrivate * create(const class QString  &, enum Format);

	void processChild(class QString, enum ChildSpec, class QMap<QString,QString> &);

	class QStringList variantListToStringList(const QVariantList  &);

	class QVariant stringListToVariantList(const class QStringList  &);

	class QString variantToString(const class QVariant  &);

	class QVariant stringToVariant(const class QString  &);

	void iniEscapedKey(const class QString  &, class QByteArray &);

	bool iniUnescapedKey(const class QByteArray  &, int, int, class QString &);

	void iniEscapedString(const class QString  &, class QByteArray &);

	void iniEscapedStringList(const class QStringList  &, class QByteArray &);

	bool iniUnescapedStringList(const class QByteArray  &, int, int, class QString &, class QStringList &);

	class QStringList splitArgs(const class QString  &, int);

}; /* size: 76, cachelines: 2 */
   /* sum members: 18, holes: 2, sum holes: 58 */
   /* last cacheline: 12 bytes */
   /* definitions: 1 */

struct QConfFile {
	struct QString             name;                 /*     0     4 */
	struct QDateTime           timeStamp;            /*     4     4 */
	qint64                     size;                 /*     8     8 */
	UnparsedSettingsMap        unparsedIniSections;  /*    16     4 */
	ParsedSettingsMap          originalKeys;         /*    20     4 */
	ParsedSettingsMap          addedKeys;            /*    24     4 */
	ParsedSettingsMap          removedKeys;          /*    28     4 */
	struct QAtomic             ref;                  /*    32     4 */
	struct QMutex              mutex;                /*    36     4 */
	bool                       userPerms;            /*    40     1 */
	ParsedSettingsMap mergedKeyMap(const class QConfFile  *);

	class QConfFile * fromName(const class QString  &, bool);

	void clearCache(void);

private:

	void QConfFile(class QConfFile *, const class QConfFile  &);

	class QConfFile & operator=(class QConfFile *, const class QConfFile  &);

	void QConfFile(class QConfFile *, const class QString  &, bool);

	void ~QConfFile(class QConfFile *, int);

}; /* size: 44, cachelines: 1 */
   /* padding: 3 */
   /* last cacheline: 44 bytes */
   /* definitions: 1 */

struct QSettingsGroup {
	struct QString             str;                  /*     0     4 */
	int                        num;                  /*     4     4 */
	int                        maxNum;               /*     8     4 */
	void QSettingsGroup(class QSettingsGroup *);

	void QSettingsGroup(class QSettingsGroup *, const class QString  &);

	void QSettingsGroup(class QSettingsGroup *, const class QString  &, bool);

	class QString name(const class QSettingsGroup  *);

	class QString toString(const class QSettingsGroup  *);

	bool isArray(const class QSettingsGroup  *);

	int arraySizeGuess(const class QSettingsGroup  *);

	void setArrayIndex(class QSettingsGroup *, int);

	void QSettingsGroup(class QSettingsGroup *, const class QSettingsGroup  &);

	void ~QSettingsGroup(class QSettingsGroup *, int);

}; /* size: 12, cachelines: 1 */
   /* last cacheline: 12 bytes */
   /* definitions: 1 */

struct QMap<QSettingsKey,QVariant> {
	union ._117 {
		class QMapData *           d;                    /*           4 */
		class Node *               e;                    /*           4 */
	};

private:

	union ._117                (null);               /*     0     4 */
	struct Node {
	}; /* size: 0, cachelines: 0 */

	struct const_iterator {
	}; /* size: 0, cachelines: 0 */

	struct iterator {
	}; /* size: 0, cachelines: 0 */

	int payload(void);

	class Node * concrete(class Node *);

	void QMap(class QMap<QSettingsKey,QVariant> *);

	void QMap(class QMap<QSettingsKey,QVariant> *, const class QMap<QSettingsKey,QVariant>  &);

	void ~QMap(class QMap<QSettingsKey,QVariant> *, int);

	class QMap<QSettingsKey,QVariant> & operator=(class QMap<QSettingsKey,QVariant> *, const class QMap<QSettingsKey,QVariant>  &);

	void QMap(class QMap<QSettingsKey,QVariant> *, const class map<QSettingsKey,QVariant,std::less<QSettingsKey>,std::allocator<std::pair<const QSettingsKey, QVariant> > >  &);

	class map<QSettingsKey,QVariant,std::less<QSettingsKey>,std::allocator<std::pair<const QSettingsKey, QVariant> > > toStdMap(const class QMap<QSettingsKey,QVariant>  *);

	bool operator==(const class QMap<QSettingsKey,QVariant>  *, const class QMap<QSettingsKey,QVariant>  &);

	bool operator!=(const class QMap<QSettingsKey,QVariant>  *, const class QMap<QSettingsKey,QVariant>  &);

	int size(const class QMap<QSettingsKey,QVariant>  *);

	bool isEmpty(const class QMap<QSettingsKey,QVariant>  *);

	void detach(class QMap<QSettingsKey,QVariant> *);

	bool isDetached(const class QMap<QSettingsKey,QVariant>  *);

	void setSharable(class QMap<QSettingsKey,QVariant> *, bool);

	void clear(class QMap<QSettingsKey,QVariant> *);

	int remove(class QMap<QSettingsKey,QVariant> *, const class QSettingsKey  &);

	class QVariant take(class QMap<QSettingsKey,QVariant> *, const class QSettingsKey  &);

	bool contains(const class QMap<QSettingsKey,QVariant>  *, const class QSettingsKey  &);

	const class QSettingsKey  key(const class QMap<QSettingsKey,QVariant>  *, const class QVariant  &);

	const class QVariant  value(const class QMap<QSettingsKey,QVariant>  *, const class QSettingsKey  &);

	const class QVariant  value(const class QMap<QSettingsKey,QVariant>  *, const class QSettingsKey  &, const class QVariant  &);

	class QVariant & operator[](class QMap<QSettingsKey,QVariant> *, const class QSettingsKey  &);

	const class QVariant  operator[](const class QMap<QSettingsKey,QVariant>  *, const class QSettingsKey  &);

	class QList<QSettingsKey> uniqueKeys(const class QMap<QSettingsKey,QVariant>  *);

	class QList<QSettingsKey> keys(const class QMap<QSettingsKey,QVariant>  *);

	class QList<QSettingsKey> keys(const class QMap<QSettingsKey,QVariant>  *, const class QVariant  &);

	class QList<QVariant> values(const class QMap<QSettingsKey,QVariant>  *);

	class QList<QVariant> values(const class QMap<QSettingsKey,QVariant>  *, const class QSettingsKey  &);

	int count(const class QMap<QSettingsKey,QVariant>  *, const class QSettingsKey  &);

	class iterator begin(class QMap<QSettingsKey,QVariant> *);

	class const_iterator begin(const class QMap<QSettingsKey,QVariant>  *);

	class const_iterator constBegin(const class QMap<QSettingsKey,QVariant>  *);

	class iterator end(class QMap<QSettingsKey,QVariant> *);

	class const_iterator end(const class QMap<QSettingsKey,QVariant>  *);

	class const_iterator constEnd(const class QMap<QSettingsKey,QVariant>  *);

	class iterator erase(class QMap<QSettingsKey,QVariant> *, class iterator);

	class iterator remove(class QMap<QSettingsKey,QVariant> *, class iterator);

	void erase(class QMap<QSettingsKey,QVariant> *, const class QSettingsKey  &);

	int count(const class QMap<QSettingsKey,QVariant>  *);

	class iterator find(class QMap<QSettingsKey,QVariant> *, const class QSettingsKey  &);

	class const_iterator find(const class QMap<QSettingsKey,QVariant>  *, const class QSettingsKey  &);

	class const_iterator constFind(const class QMap<QSettingsKey,QVariant>  *, const class QSettingsKey  &);

	class iterator lowerBound(class QMap<QSettingsKey,QVariant> *, const class QSettingsKey  &);

	class const_iterator lowerBound(const class QMap<QSettingsKey,QVariant>  *, const class QSettingsKey  &);

	class iterator upperBound(class QMap<QSettingsKey,QVariant> *, const class QSettingsKey  &);

	class const_iterator upperBound(const class QMap<QSettingsKey,QVariant>  *, const class QSettingsKey  &);

	class iterator insert(class QMap<QSettingsKey,QVariant> *, const class QSettingsKey  &, const class QVariant  &);

	class iterator insert(class QMap<QSettingsKey,QVariant> *, const class QSettingsKey  &, const class QVariant  &, bool);

	class iterator insertMulti(class QMap<QSettingsKey,QVariant> *, const class QSettingsKey  &, const class QVariant  &);

	class iterator replace(class QMap<QSettingsKey,QVariant> *, const class QSettingsKey  &, const class QVariant  &);

	class QMap<QSettingsKey,QVariant> & unite(class QMap<QSettingsKey,QVariant> *, const class QMap<QSettingsKey,QVariant>  &);

	bool empty(const class QMap<QSettingsKey,QVariant>  *);

	void detach_helper(class QMap<QSettingsKey,QVariant> *);

	void freeData(class QMap<QSettingsKey,QVariant> *, class QMapData *);

	class Node * findNode(const class QMap<QSettingsKey,QVariant>  *, const class QSettingsKey  &);

	class Node * mutableFindNode(const class QMap<QSettingsKey,QVariant>  *, class Node * *, const class QSettingsKey  &);

	class Node * node_create(class QMap<QSettingsKey,QVariant> *, class QMapData *, class Node * *, const class QSettingsKey  &, const class QVariant  &);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QMap<QSettingsKey,QByteArray> {
	union ._117 {
		class QMapData *           d;                    /*           4 */
		class Node *               e;                    /*           4 */
	};

private:

	union ._117                (null);               /*     0     4 */
	struct Node {
	}; /* size: 0, cachelines: 0 */

	struct const_iterator {
	}; /* size: 0, cachelines: 0 */

	struct iterator {
	}; /* size: 0, cachelines: 0 */

	int payload(void);

	class Node * concrete(class Node *);

	void QMap(class QMap<QSettingsKey,QByteArray> *);

	void QMap(class QMap<QSettingsKey,QByteArray> *, const class QMap<QSettingsKey,QByteArray>  &);

	void ~QMap(class QMap<QSettingsKey,QByteArray> *, int);

	class QMap<QSettingsKey,QByteArray> & operator=(class QMap<QSettingsKey,QByteArray> *, const class QMap<QSettingsKey,QByteArray>  &);

	void QMap(class QMap<QSettingsKey,QByteArray> *, const class map<QSettingsKey,QByteArray,std::less<QSettingsKey>,std::allocator<std::pair<const QSettingsKey, QByteArray> > >  &);

	class map<QSettingsKey,QByteArray,std::less<QSettingsKey>,std::allocator<std::pair<const QSettingsKey, QByteArray> > > toStdMap(const class QMap<QSettingsKey,QByteArray>  *);

	bool operator==(const class QMap<QSettingsKey,QByteArray>  *, const class QMap<QSettingsKey,QByteArray>  &);

	bool operator!=(const class QMap<QSettingsKey,QByteArray>  *, const class QMap<QSettingsKey,QByteArray>  &);

	int size(const class QMap<QSettingsKey,QByteArray>  *);

	bool isEmpty(const class QMap<QSettingsKey,QByteArray>  *);

	void detach(class QMap<QSettingsKey,QByteArray> *);

	bool isDetached(const class QMap<QSettingsKey,QByteArray>  *);

	void setSharable(class QMap<QSettingsKey,QByteArray> *, bool);

	void clear(class QMap<QSettingsKey,QByteArray> *);

	int remove(class QMap<QSettingsKey,QByteArray> *, const class QSettingsKey  &);

	class QByteArray take(class QMap<QSettingsKey,QByteArray> *, const class QSettingsKey  &);

	bool contains(const class QMap<QSettingsKey,QByteArray>  *, const class QSettingsKey  &);

	const class QSettingsKey  key(const class QMap<QSettingsKey,QByteArray>  *, const class QByteArray  &);

	const class QByteArray  value(const class QMap<QSettingsKey,QByteArray>  *, const class QSettingsKey  &);

	const class QByteArray  value(const class QMap<QSettingsKey,QByteArray>  *, const class QSettingsKey  &, const class QByteArray  &);

	class QByteArray & operator[](class QMap<QSettingsKey,QByteArray> *, const class QSettingsKey  &);

	const class QByteArray  operator[](const class QMap<QSettingsKey,QByteArray>  *, const class QSettingsKey  &);

	class QList<QSettingsKey> uniqueKeys(const class QMap<QSettingsKey,QByteArray>  *);

	class QList<QSettingsKey> keys(const class QMap<QSettingsKey,QByteArray>  *);

	class QList<QSettingsKey> keys(const class QMap<QSettingsKey,QByteArray>  *, const class QByteArray  &);

	class QList<QByteArray> values(const class QMap<QSettingsKey,QByteArray>  *);

	class QList<QByteArray> values(const class QMap<QSettingsKey,QByteArray>  *, const class QSettingsKey  &);

	int count(const class QMap<QSettingsKey,QByteArray>  *, const class QSettingsKey  &);

	class iterator begin(class QMap<QSettingsKey,QByteArray> *);

	class const_iterator begin(const class QMap<QSettingsKey,QByteArray>  *);

	class const_iterator constBegin(const class QMap<QSettingsKey,QByteArray>  *);

	class iterator end(class QMap<QSettingsKey,QByteArray> *);

	class const_iterator end(const class QMap<QSettingsKey,QByteArray>  *);

	class const_iterator constEnd(const class QMap<QSettingsKey,QByteArray>  *);

	class iterator erase(class QMap<QSettingsKey,QByteArray> *, class iterator);

	class iterator remove(class QMap<QSettingsKey,QByteArray> *, class iterator);

	void erase(class QMap<QSettingsKey,QByteArray> *, const class QSettingsKey  &);

	int count(const class QMap<QSettingsKey,QByteArray>  *);

	class iterator find(class QMap<QSettingsKey,QByteArray> *, const class QSettingsKey  &);

	class const_iterator find(const class QMap<QSettingsKey,QByteArray>  *, const class QSettingsKey  &);

	class const_iterator constFind(const class QMap<QSettingsKey,QByteArray>  *, const class QSettingsKey  &);

	class iterator lowerBound(class QMap<QSettingsKey,QByteArray> *, const class QSettingsKey  &);

	class const_iterator lowerBound(const class QMap<QSettingsKey,QByteArray>  *, const class QSettingsKey  &);

	class iterator upperBound(class QMap<QSettingsKey,QByteArray> *, const class QSettingsKey  &);

	class const_iterator upperBound(const class QMap<QSettingsKey,QByteArray>  *, const class QSettingsKey  &);

	class iterator insert(class QMap<QSettingsKey,QByteArray> *, const class QSettingsKey  &, const class QByteArray  &);

	class iterator insert(class QMap<QSettingsKey,QByteArray> *, const class QSettingsKey  &, const class QByteArray  &, bool);

	class iterator insertMulti(class QMap<QSettingsKey,QByteArray> *, const class QSettingsKey  &, const class QByteArray  &);

	class iterator replace(class QMap<QSettingsKey,QByteArray> *, const class QSettingsKey  &, const class QByteArray  &);

	class QMap<QSettingsKey,QByteArray> & unite(class QMap<QSettingsKey,QByteArray> *, const class QMap<QSettingsKey,QByteArray>  &);

	bool empty(const class QMap<QSettingsKey,QByteArray>  *);

	void detach_helper(class QMap<QSettingsKey,QByteArray> *);

	void freeData(class QMap<QSettingsKey,QByteArray> *, class QMapData *);

	class Node * findNode(const class QMap<QSettingsKey,QByteArray>  *, const class QSettingsKey  &);

	class Node * mutableFindNode(const class QMap<QSettingsKey,QByteArray>  *, class Node * *, const class QSettingsKey  &);

	class Node * node_create(class QMap<QSettingsKey,QByteArray> *, class QMapData *, class Node * *, const class QSettingsKey  &, const class QByteArray  &);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QSettingsKey : public QString {
public:

	struct QString             (null);               /*     0     4 */
private:

	struct QString             theOriginalKey;       /*     4     4 */
	void QSettingsKey(class QSettingsKey *, const class QString  &, enum CaseSensitivity);

	class QString originalCaseKey(const class QSettingsKey  *);

	void QSettingsKey(class QSettingsKey *, const class QSettingsKey  &);

	void ~QSettingsKey(class QSettingsKey *, int);

}; /* size: 8, cachelines: 1 */
   /* last cacheline: 8 bytes */
   /* definitions: 1 */

struct QMutexLocker {
	union ._230 {
		class QMutex *             mtx;                  /*           4 */
		quintptr                   val;                  /*           4 */
	};

private:

	union ._230                (null);               /*     0     4 */
	void QMutexLocker(class QMutexLocker *, class QMutex *);

	void ~QMutexLocker(class QMutexLocker *, int);

	void unlock(class QMutexLocker *);

	void relock(class QMutexLocker *);

	class QMutex * mutex(const class QMutexLocker  *);

	void QMutexLocker(class QMutexLocker *, const class QMutexLocker  &);

	class QMutexLocker & operator=(class QMutexLocker *, const class QMutexLocker  &);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct QMutex {
	enum RecursionMode {
		NonRecursive = 0,
		Recursive = 1,
	};

private:

	class QMutexPrivate *      d;                    /*     0     4 */
	void QMutex(class QMutex *, enum RecursionMode);

	void ~QMutex(class QMutex *, int);

	void lock(class QMutex *);

	bool tryLock(class QMutex *);

	void unlock(class QMutex *);

	bool locked(class QMutex *);

	void QMutex(class QMutex *, bool);

	void QMutex(class QMutex *, const class QMutex  &);

	class QMutex & operator=(class QMutex *, const class QMutex  &);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 1 */

struct const_iterator {
	class Node *               i;                    /*     0     4 */
	void const_iterator(class const_iterator *);

	void const_iterator(class const_iterator *, class Node *);

	void const_iterator(class const_iterator *, const class const_iterator  &);

	void const_iterator(class const_iterator *, const class iterator  &);

	const class QString  & operator*(const class const_iterator  *);

	const class QString  * operator->(const class const_iterator  *);

	const class QString  & operator[](const class const_iterator  *, int);

	bool operator==(const class const_iterator  *, const class const_iterator  &);

	bool operator!=(const class const_iterator  *, const class const_iterator  &);

	bool operator<(const class const_iterator  *, const class const_iterator  &);

	bool operator<=(const class const_iterator  *, const class const_iterator  &);

	bool operator>(const class const_iterator  *, const class const_iterator  &);

	bool operator>=(const class const_iterator  *, const class const_iterator  &);

	class const_iterator & operator++(class const_iterator *);

	class const_iterator operator++(class const_iterator *, int);

	class const_iterator & operator--(class const_iterator *);

	class const_iterator operator--(class const_iterator *, int);

	class const_iterator & operator+=(class const_iterator *, int);

	class const_iterator & operator-=(class const_iterator *, int);

	class const_iterator operator+(const class const_iterator  *, int);

	class const_iterator operator-(const class const_iterator  *, int);

	int operator-(const class const_iterator  *, class const_iterator);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 8 */

struct iterator {
	class Node *               i;                    /*     0     4 */
	void iterator(class iterator *);

	void iterator(class iterator *, class Node *);

	void iterator(class iterator *, const class iterator  &);

	class QString & operator*(const class iterator  *);

	class QString * operator->(const class iterator  *);

	class QString & operator[](const class iterator  *, int);

	bool operator==(const class iterator  *, const class iterator  &);

	bool operator!=(const class iterator  *, const class iterator  &);

	bool operator<(const class iterator  *, const class iterator  &);

	bool operator<=(const class iterator  *, const class iterator  &);

	bool operator>(const class iterator  *, const class iterator  &);

	bool operator>=(const class iterator  *, const class iterator  &);

	bool operator==(const class iterator  *, const class const_iterator  &);

	bool operator!=(const class iterator  *, const class const_iterator  &);

	bool operator<(const class iterator  *, const class const_iterator  &);

	bool operator<=(const class iterator  *, const class const_iterator  &);

	bool operator>(const class iterator  *, const class const_iterator  &);

	bool operator>=(const class iterator  *, const class const_iterator  &);

	class iterator & operator++(class iterator *);

	class iterator operator++(class iterator *, int);

	class iterator & operator--(class iterator *);

	class iterator operator--(class iterator *, int);

	class iterator & operator+=(class iterator *, int);

	class iterator & operator-=(class iterator *, int);

	class iterator operator+(const class iterator  *, int);

	class iterator operator-(const class iterator  *, int);

	int operator-(const class iterator  *, class iterator);

}; /* size: 4, cachelines: 1 */
   /* last cacheline: 4 bytes */
   /* definitions: 10 */

struct QList<QString> {
	union ._105 {
		struct QListData           p;                    /*           4 */
		class Data *               d;                    /*           4 */
	};

private:

	union ._105                (null);               /*     0     4 */
	struct Node {
	}; /* size: 0, cachelines: 0 */

	struct const_iterator {
	}; /* size: 0, cachelines: 0 */

	struct iterator {
	}; /* size: 0, cachelines: 0 */

	void QList(class QList<QString> *);

	void QList(class QList<QString> *, const class QList<QString>  &);

	void ~QList(class QList<QString> *, int);

	class QList<QString> & operator=(class QList<QString> *, const class QList<QString>  &);

	bool operator==(const class QList<QString>  *, const class QList<QString>  &);

	bool operator!=(const class QList<QString>  *, const class QList<QString>  &);

	int size(const class QList<QString>  *);

	void detach(class QList<QString> *);

	bool isDetached(const class QList<QString>  *);

	void setSharable(class QList<QString> *, bool);

	bool isEmpty(const class QList<QString>  *);

	void clear(class QList<QString> *);

	const class QString  & at(const class QList<QString>  *, int);

	const class QString  & operator[](const class QList<QString>  *, int);

	class QString & operator[](class QList<QString> *, int);

	void append(class QList<QString> *, const class QString  &);

	void prepend(class QList<QString> *, const class QString  &);

	void insert(class QList<QString> *, int, const class QString  &);

	void replace(class QList<QString> *, int, const class QString  &);

	void removeAt(class QList<QString> *, int);

	int removeAll(class QList<QString> *, const class QString  &);

	class QString takeAt(class QList<QString> *, int);

	class QString takeFirst(class QList<QString>