;
typedef long unsigned int size_t;
extern "C" {
__extension__ 
typedef struct
  {}
 lldiv_t;;;
extern "C" {;
typedef unsigned short int ushort;;;;;;
};;};
namespace std __attribute__ ((__visibility__ ("default"))) {;};;
template <int> class QUintForSize {};;
template <> class QUintForSize<8> {
};;
template <int> class QIntForSize {};;
template <> class QIntForSize<8> {
};;
class QSysInfo {
};;
class QFlag
{;};
template<typename Enum>
class QFlags
{;};;
struct QLatin1Char
{
private:
    char ch;
};
class QChar {;
private:
    ushort ucs;
};;
class QBasicAtomicInt
{;};
template <typename T>
class QBasicAtomicPointer
{;};;
class QByteArray
{;};;
namespace
Qt {;;;};
namespace std __attribute__ ((__visibility__ ("default"))) {
  template<class _CharT>
    struct char_traits;;}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
}
namespace std __attribute__ ((__visibility__ ("default"))) {;}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {;}
namespace std __attribute__ ((__visibility__ ("default"))) {
}
namespace std __attribute__ ((__visibility__ ("default"))) {;}
namespace std __attribute__ ((__visibility__ ("default"))) {;}
namespace std __attribute__ ((__visibility__ ("default"))) {;
  template<bool _BoolType>
    struct __lexicographical_compare
    {
};;};;;
namespace std __attribute__ ((__visibility__ ("default"))) {
}
namespace std __attribute__ ((__visibility__ ("default"))) {
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
  template<typename _CharT>
    struct char_traits
    {;};
}
namespace std __attribute__ ((__visibility__ ("default"))) {
  template<>
    struct char_traits<char>
    {;};
  template<>
    struct char_traits<wchar_t>
    {;};
}
namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {;
  template<typename _Tp>
    class new_allocator
    {
    public:;;
typedef _Tp& reference;;
      template<typename _Tp1>
        struct rebind
        {
 
typedef new_allocator<_Tp1> other;
};
};
}
namespace std __attribute__ ((__visibility__ ("default"))) {;
  template<typename _Tp>
    class allocator: public __gnu_cxx::new_allocator<_Tp>
    {};;}
namespace std __attribute__ ((__visibility__ ("default"))) {;}
namespace std __attribute__ ((__visibility__ ("default"))) {;};;;
extern "C" {;};;
namespace std __attribute__ ((__visibility__ ("default"))) {
  template<typename _CharT, typename _Traits, typename _Alloc>
    class basic_string
    {;
    private:
      struct _Rep_base
      {};
      struct _Rep : _Rep_base
      {;};
      struct _Alloc_hider : _Alloc
      {
 _CharT* _M_p;
};;};;};;
class QString
{;;;;;
private:
    struct Data {};
    static Data shared_null;;
    Data *d;;
    static Data *fromAscii_helper(const char *str, int size = -1);;};
class QLatin1String
{
private:
    const char *chars;
};
class QCharRef {;};;
class QStringRef {;};;
class QGenericArgument
{
private:
    const void *_data;
    const char *_name;
};;
struct QMetaObject
{;};;
namespace std __attribute__ ((__visibility__ ("default"))) {;};;
struct QListData {;};
template <typename T>
class QList
{
    union {;};;};;
class QObject
{;};;
class QIODevice
    : public QObject
{; private:
public:;;};;
class QFile : public QIODevice
{;;;};;
class QTextStream
{;};;
class QDataStream
{;};;
class QStringList : public QList<QString>
{;};;
class QDir
{;
public:;;;};;
class CString
{;};;
namespace std __attribute__ ((__visibility__ ("default"))) {
  template<typename _ForwardIterator, typename _Allocator>
    void
    _Destroy(_ForwardIterator __first, _ForwardIterator __last,
      _Allocator& __alloc)
    {}
}
namespace std __attribute__ ((__visibility__ ("default"))) {;};;
namespace std __attribute__ ((__visibility__ ("default"))) {;
  template<typename _Key, typename _Val, typename _KeyOfValue,
           typename _Compare, typename _Alloc = allocator<_Val> >
    class _Rb_tree
    {;};;}
namespace std __attribute__ ((__visibility__ ("default"))) {
}
struct QMapData
{;;};
template <class Key, class T>
class QMap
{
    union {;};;};
template <class Key, class T>
class QMultiMap : public QMap<Key, T>
{;};;
namespace std __attribute__ ((__visibility__ ("default"))) {
  
  struct __numeric_limits_base
  {};
  template<typename _Tp>
    struct numeric_limits : public __numeric_limits_base
    {};;
  template<>
    struct numeric_limits<unsigned int>
    {;};;};;
namespace std __attribute__ ((__visibility__ ("default"))) {
  template<typename _Tp, typename _Alloc>
    struct _Vector_base
    {
      
typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type;
      struct _Vector_impl
      : public _Tp_alloc_type
      {
 _Tp* _M_start;
 _Tp* _M_finish;
 _Tp* _M_end_of_storage;
};;
      _Tp_alloc_type&
      _M_get_Tp_allocator()
      {}
      ~_Vector_base()
      {
 
/* fs103072 */  _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage
        - this->_M_impl._M_start);
}
    public:
      _Vector_impl _M_impl;
      void
      _M_deallocate(_Tp* __p, size_t __n)
      {}
};
  template<typename _Tp, typename _Alloc = std::allocator<_Tp> >
    class vector : protected _Vector_base<_Tp, _Alloc>
    {
      
typedef _Vector_base<_Tp, _Alloc> _Base;;
typedef typename _Base::_Tp_alloc_type _Tp_alloc_type;;;
typedef typename _Tp_alloc_type::reference reference;;;
typedef size_t size_type;;;
      using _Base::_M_get_Tp_allocator;
    public:
      vector()
      : _Base() {}
      ~vector()
      {
 
/* fs103079 */  std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish,
        _M_get_Tp_allocator());
};;
      size_type
      size() const
      {
 
/* fs103090 */  return size_type(this->_M_impl._M_finish - this->_M_impl._M_start);
};
      reference
      operator[](size_type __n)
      {};;};
}
extern "C" {;};;
class R2{;};;
class R3{;};;
class GeomTet3D{;};;
class PhysMedia{;};;
class R3xR3{
};;
class PhysMedia3D : public PhysMedia
{;};;
class IsotropicMedia3D : public PhysMedia3D{
};;
class AnisotropicMedia3D : public PhysMedia3D{
};;
class PhysMedia2D : public PhysMedia{
};;
class PhysMedia1D : public PhysMedia{
};;
namespace CCommunicationConstants
{;};;
class SparseSystem{};;
class SparsePreconditioner{;
 std::vector<double *> m_tmpYVector;;
public:
 SparsePreconditioner(SparseSystem *sparseSys = __null);
 virtual ~SparsePreconditioner()
 {
 
/* fs105592 */ 
  for (size_t i = 0;
 i < m_tmpYVector.size();
 ++i)
   delete [] m_tmpYVector[i];
};;};
class NonSymSparsePreconditioner : public SparsePreconditioner
{
protected:
public:
 NonSymSparsePreconditioner(SparseSystem *sparseSys = __null)
  : SparsePreconditioner(sparseSys) {}
};;
class NonSymSparsePreconditioner3 : public NonSymSparsePreconditioner
{
public:
 NonSymSparsePreconditioner3(SparseSystem *sparseSys = __null);;};;
class CBaseAbortFunction
{};;
class CPAbortFunction : public CBaseAbortFunction
{;};;
NonSymSparsePreconditioner3::NonSymSparsePreconditioner3(SparseSystem *sparseSys)
: NonSymSparsePreconditioner(sparseSys)
{}