#ifndef QBYTEARRAY_H
#define QBYTEARRAY_H 
#include <QtCore/qglobal.h>
#ifndef QATOMIC_H
#define QATOMIC_H 
#if defined(QT_MOC) || defined(QT_BUILD_QMAKE) || defined(QT_RCC) || defined(QT_UIC)
#else
#include <QtCore/qatomic_arch.h>
#endif
#include <QtCore/qglobal.h>
#ifndef Q_SPECIALIZED_QATOMIC
struct QBasicAtomic{
   public: int volatile atomic;
   public: inline void init(int x = 0);
   public: inline bool ref();
   public: inline bool deref();
   public: inline bool operator ==(int x) const
   public: inline bool operator !=(int x) const
   public: inline bool operator !() const
   public: inline operator int () const
   public: inline struct QBasicAtomic& operator =(int x);
   public: inline bool testAndSet(int expected, int newval);
   public: inline bool testAndSetAcquire(int expected, int newval);
   public: inline bool testAndSetRelease(int expected, int newval);
   public: inline int exchange(int newval);
};
template < typename T > struct QBasicAtomicPointer{
   public: T volatile * pointer;
   public: inline void init(T* t = 0);
   public: inline bool operator ==(T* t) const
   public: inline bool operator !=(T* t) const
   public: inline bool operator !() const
   public: inline operator T* () const
   public: inline T* operator ->() const
   public: inline struct QBasicAtomicPointer& operator =(T* t);
   public: inline bool testAndSet(T* expected, T* newval);
   public: inline T* exchange(T* newval);
};
#define Q_ATOMIC_INIT(a) { (a) }

#endif // Q_SPECIALIZED_QATOMIC
template < typename T > inline T qAtomicSetPtr(T volatile * ptr, T newval);
class QAtomic: public QBasicAtomic{
   public: inline QAtomic(int x = 0);
   public: inline QAtomic(class QAtomic const & copy);
   public: inline class QAtomic& operator =(int x);
   public: inline class QAtomic& operator =(class QAtomic const & copy);
};
template < typename T > class QAtomicPointer: public QBasicAtomicPointer < T >{
   public: inline QAtomicPointer(T* t = 0);
   public: inline QAtomicPointer(class QAtomicPointer const & copy);
   public: inline class QAtomicPointer& operator =(T* t);
   public: inline class QAtomicPointer& operator =(class QAtomicPointer const & copy);
};
template < typename T > inline void qAtomicAssign(T* & d, T* x);
template < typename T > inline void qAtomicAssign(class QBasicAtomicPointer < T >& d, T* x);
template < typename T > inline void qAtomicAssign(class QBasicAtomicPointer < T >& d, class QBasicAtomicPointer < T > const & x);
template < typename T > inline void qAtomicDetach(T* & d);
template < typename T > inline void qAtomicDetach(class QBasicAtomicPointer < T >& d);
#endif // QATOMIC_H
#include <string.h>
#include <stdarg.h>
typedef enum QtValidLicenseForCoreModule QtCoreModule;
char* qstrdup(char const *);
inline uint qstrlen(char const * str);
inline uint qstrnlen(char const * str, uint maxlen);
char* qstrcpy(char* dst, char const * src);
char* qstrncpy(char* dst, char const * src, uint len);
int qstrcmp(char const * str1, char const * str2);
inline int qstrncmp(char const * str1, char const * str2, uint len);
int qstricmp(char const *, char const *);
int qstrnicmp(char const *, char const *, uint len);
int qvsnprintf(char* str, size_t n, char const * fmt, struct __va_list_tag* ap);
int qsnprintf(char* str, size_t n, char const * fmt, ...);
quint16 qChecksum(char const * s, uint len);
template < typename T > struct QList;
class QByteArray{
   public: QByteArray(char const *);
   public: QByteArray(char const *, int size);
   public: QByteArray(int size, char c);
   public: class QByteArray& operator =(class QByteArray const &);
   public: class QByteArray& operator =(char const * str);
   public: void resize(int size);
   public: class QByteArray& fill(char c, int size = -1);
   public: void clear();
   public: int indexOf(char c, int from = 0) const
   public: int indexOf(class QByteArray const & a, int from = 0) const
   public: int lastIndexOf(char c, int from = -1) const
   public: int lastIndexOf(class QByteArray const & a, int from = -1) const
   public: int count(char c) const
   public: int count(char const * a) const
   public: int count(class QByteArray const & a) const
   public: class QByteArray left(int len) const
   public: class QByteArray right(int len) const
   public: class QByteArray mid(int index, int len = -1) const
   public: bool startsWith(class QByteArray const & a) const
   public: bool startsWith(char c) const
   public: bool startsWith(char const * c) const
   public: bool endsWith(class QByteArray const & a) const
   public: bool endsWith(char c) const
   public: bool endsWith(char const * c) const
   public: void truncate(int pos);
   public: void chop(int n);
   public: class QByteArray toLower() const
   public: class QByteArray toUpper() const
   public: class QByteArray trimmed() const
   public: class QByteArray simplified() const
   public: class QByteArray leftJustified(int width, char fill = 32, bool truncate = 0) const
   public: class QByteArray rightJustified(int width, char fill = 32, bool truncate = 0) const
   public: class QByteArray& prepend(char c);
   public: class QByteArray& prepend(char const * s);
   public: class QByteArray& prepend(class QByteArray const & a);
   public: class QByteArray& append(char c);
   public: class QByteArray& append(char const * s);
   public: class QByteArray& append(class QByteArray const & a);
   public: class QByteArray& insert(int i, char c);
   public: class QByteArray& insert(int i, char const * s);
   public: class QByteArray& insert(int i, class QByteArray const & a);
   public: class QByteArray& remove(int index, int len);
   public: class QByteArray& replace(int index, int len, class QByteArray const & s);
   public: class QByteArray& replace(char before, class QByteArray const & after);
   public: class QByteArray& replace(class QByteArray const & before, class QByteArray const & after);
   public: class QByteArray& replace(char before, char after);
   public: class QList < class QByteArray > split(char sep) const
#ifndef QT_NO_CAST_TO_ASCII
   public: class QByteArray& append(struct QString const & s);
   public: class QByteArray& insert(int i, struct QString const & s);
   public: class QByteArray& replace(struct QString const & before, char const * after);
   public: class QByteArray& replace(char c, struct QString const & after);
   public: class QByteArray& replace(struct QString const & before, class QByteArray const & after);
   public: class QByteArray& operator +=(struct QString const & s);
   public: int indexOf(struct QString const & s, int from = 0) const
   public: int lastIndexOf(struct QString const & s, int from = -1) const
#endif
#ifndef QT_NO_CAST_FROM_ASCII
   public: inline bool operator ==(struct QString const & s2) const
   public: inline bool operator !=(struct QString const & s2) const
   public: inline bool operator <(struct QString const & s2) const
   public: inline bool operator >(struct QString const & s2) const
   public: inline bool operator <=(struct QString const & s2) const
   public: inline bool operator >=(struct QString const & s2) const
#endif
   public: short int toShort(bool* ok = 0, int base = 10) const
   public: ushort toUShort(bool* ok = 0, int base = 10) const
   public: int toInt(bool* ok = 0, int base = 10) const
   public: uint toUInt(bool* ok = 0, int base = 10) const
   public: long int toLong(bool* ok = 0, int base = 10) const
   public: ulong toULong(bool* ok = 0, int base = 10) const
   public: qlonglong toLongLong(bool* ok = 0, int base = 10) const
   public: qulonglong toULongLong(bool* ok = 0, int base = 10) const
   public: float toFloat(bool* ok = 0) const
   public: double toDouble(bool* ok = 0) const
   public: class QByteArray toBase64() const
   public: class QByteArray& setNum(qlonglong, int base = 10);
   public: class QByteArray& setNum(qulonglong, int base = 10);
   public: class QByteArray& setNum(double, char f = 103, int prec = 6);
   public: static class QByteArray number(int, int base = 10);
   public: static class QByteArray number(uint, int base = 10);
   public: static class QByteArray number(qlonglong, int base = 10);
   public: static class QByteArray number(qulonglong, int base = 10);
   public: static class QByteArray number(double, char f = 103, int prec = 6);
   public: static class QByteArray fromRawData(char const *, int size);
   public: static class QByteArray fromBase64(class QByteArray const & base64);
   public: typedef char* iterator;
   public: typedef char const * const_iterator;
   public: typedef char* Iterator;
   public: typedef char const * ConstIterator;
   public: typedef char const & const_reference;
   public: typedef char& reference;
   public: inline int count() const
   public: inline int length() const
   public: bool isNull() const
   private: operator QNoImplicitBoolCast () const
   private: struct Data{
      public: struct QBasicAtomic ref;
      public: int alloc;
      public: int size;
      public: char* data;
      public: char array[1];
   };
   private: static struct QByteArray::Data shared_null;
   private: static struct QByteArray::Data shared_empty;
   private: struct QByteArray::Data* d;
   private: inline QByteArray(struct QByteArray::Data* dd, int, int);
   private: void realloc(int alloc);
   private: void expand(int i);
   public: inline QByteArray();
   public: inline ~QByteArray();
   public: inline int size() const
   public: inline char const at(int i) const
   public: inline char const operator [](int i) const
   public: inline char const operator [](uint i) const
   public: inline bool isEmpty() const
   public: inline operator char const * () const
   public: inline operator void const * () const
   public: inline char* data();
   public: inline char const * data() const
   public: inline char const * constData() const
   public: inline void detach();
   public: inline bool isDetached() const
   public: inline QByteArray(class QByteArray const & a);
   public: inline int capacity() const
   public: inline void reserve(int asize);
   public: inline void squeeze();
   public: inline class QByteRef operator [](int i);
   public: inline class QByteRef operator [](uint i);
   public: inline char* begin();
   public: inline char const * begin() const
   public: inline char const * constBegin() const
   public: inline char* end();
   public: inline char const * end() const
   public: inline char const * constEnd() const
   public: inline class QByteArray& operator +=(char c);
   public: inline class QByteArray& operator +=(char const * s);
   public: inline class QByteArray& operator +=(class QByteArray const & a);
   public: inline void push_back(char c);
   public: inline void push_back(char const * c);
   public: inline void push_back(class QByteArray const & a);
   public: inline void push_front(char c);
   public: inline void push_front(char const * c);
   public: inline void push_front(class QByteArray const & a);
   public: inline class QBool contains(class QByteArray const & a) const
   public: inline class QBool contains(char c) const
   public: inline int indexOf(char const * c, int i = 0) const
   public: inline int lastIndexOf(char const * c, int i = -1) const
   public: inline class QBool contains(char const * c) const
   public: inline class QByteArray& replace(int index, int len, char const * c);
   public: inline class QByteArray& replace(char before, char const * c);
   public: inline class QByteArray& replace(class QByteArray const & before, char const * c);
   public: inline class QByteArray& replace(char const * c, class QByteArray const & after);
   public: inline class QByteArray& replace(char const * before, char const * after);
   public: inline class QByteArray& setNum(short int n, int base = 10);
   public: inline class QByteArray& setNum(ushort n, int base = 10);
   public: inline class QByteArray& setNum(int n, int base = 10);
   public: inline class QByteArray& setNum(uint n, int base = 10);
   public: inline class QByteArray& setNum(float n, char f = 103, int prec = 6);
   friend class QByteRef;
   friend struct QString;
};
class QByteRef{
   private: class QByteArray& a;
   private: int i;
   private: inline QByteRef(class QByteArray& array, int idx);
   public: inline operator char const () const
   public: inline class QByteRef& operator =(char c);
   public: inline class QByteRef& operator =(class QByteRef const & c);
   public: inline bool operator ==(char c) const
   public: inline bool operator !=(char c) const
   public: inline bool operator >(char c) const
   public: inline bool operator >=(char c) const
   public: inline bool operator <(char c) const
   public: inline bool operator <=(char c) const
   friend class QByteArray;
};
inline bool operator ==(class QByteArray const & a1, class QByteArray const & a2);
inline bool operator ==(class QByteArray const & a1, char const * a2);
inline bool operator ==(char const * a1, class QByteArray const & a2);
inline bool operator !=(class QByteArray const & a1, class QByteArray const & a2);
inline bool operator !=(class QByteArray const & a1, char const * a2);
inline bool operator !=(char const * a1, class QByteArray const & a2);
inline bool operator <(class QByteArray const & a1, class QByteArray const & a2);
inline bool operator <(class QByteArray const & a1, char const * a2);
inline bool operator <(char const * a1, class QByteArray const & a2);
inline bool operator <=(class QByteArray const & a1, class QByteArray const & a2);
inline bool operator <=(class QByteArray const & a1, char const * a2);
inline bool operator <=(char const * a1, class QByteArray const & a2);
inline bool operator >(class QByteArray const & a1, class QByteArray const & a2);
inline bool operator >(class QByteArray const & a1, char const * a2);
inline bool operator >(char const * a1, class QByteArray const & a2);
inline bool operator >=(class QByteArray const & a1, class QByteArray const & a2);
inline bool operator >=(class QByteArray const & a1, char const * a2);
inline bool operator >=(char const * a1, class QByteArray const & a2);
inline QByteArray operator +(class QByteArray const & a1, class QByteArray const & a2);
inline QByteArray operator +(class QByteArray const & a1, char const * a2);
inline QByteArray operator +(class QByteArray const & a1, char a2);
inline QByteArray operator +(char const * a1, class QByteArray const & a2);
inline QByteArray operator +(char a1, class QByteArray const & a2);
#ifndef QT_NO_DATASTREAM
struct QDataStream& operator <<(struct QDataStream&, class QByteArray const &);
struct QDataStream& operator >>(struct QDataStream&, class QByteArray&);
#endif
#ifndef QT_NO_COMPRESS
class QByteArray qCompress(uchar const * data, int nbytes, int compressionLevel = -1);
class QByteArray qUncompress(uchar const * data, int nbytes);
inline class QByteArray qCompress(class QByteArray const & data, int compressionLevel = -1);
inline class QByteArray qUncompress(class QByteArray const & data);
#endif
template < > class QTypeInfo < class QByteArray >{
   public: static inline char const * name();
   public: enum /*anonymous*/{
      isComplex = 1,
      isStatic = 0,
      isLarge = 0,
      isPointer = 0,
      isDummy = 0,
   };
};
#endif // QBYTEARRAY_H