diff --git a/SConstruct b/SConstruct
index 5df6f96a..013375b7 100644
--- a/SConstruct
+++ b/SConstruct
@@ -37,6 +37,14 @@ def setup_config_variables():
     if 'ZLIBPATH' in os.environ:
         zlibpath = os.environ['ZLIBPATH']
 
+    git = 'git'
+    if 'GIT' in os.environ:
+        git = os.environ['GIT']
+
+    mercurial = 'hg'
+    if 'MERCURIAL' in os.environ:
+        hg = os.environ['HG']
+
     vars = Variables('scons_configure.py')
     vars.AddVariables(
         PathVariable('BOOSTPATH', 'Set to point to your boost directory',
@@ -51,7 +59,13 @@ def setup_config_variables():
         PathVariable('SEVENZIPPATH', 'Path to 7zip sources', sevenzippath,
                                                         PathVariable.PathIsDir),
         PathVariable('ZLIBPATH', 'Path to zlib install', zlibpath,
-                                                        PathVariable.PathIsDir)
+                                                        PathVariable.PathIsDir),
+        PathVariable('GIT', 'Path to git executable', git,
+                                                       PathVariable.PathIsFile),
+        PathVariable('MERCURIAL', 'Path to hg executable', mercurial,
+                                                       PathVariable.PathIsFile),
+        PathVariable('IWYU', 'Path to include-what-you-use executable', None,
+                                                        PathVariable.PathIsFile)
     )
 
     return vars
@@ -231,6 +245,157 @@ def DisableQtModules(self, *modules):
     for module in modules:
         self['CPPPATH'].remove(os.path.join('$QTDIR', 'include', 'QT' + module))
 
+def setup_IWYU(env):
+    import SCons.Defaults
+    import SCons.Builder
+    original_shared = SCons.Defaults.SharedObjectEmitter
+    original_static = SCons.Defaults.StaticObjectEmitter
+
+    def DoIWYU(env, source, target):
+        for i in range(len(source)):
+            s = source[i]
+            dir, name = os.path.split(str(s)) # I'm sure theres a way of getting this from scons
+            # Don't bother looking at moc files and 7zip source
+            if not name.startswith('moc_') and \
+               not dir.startswith(env['SEVENZIPPATH']):
+                # Put the .iwyu in the same place as the .obj
+                targ = os.path.splitext(str(target[i]))[0]
+                env.Depends(env.IWYU(targ + '.iwyu', s), target[i])
+
+    def shared_emitter(target, source, env):
+        DoIWYU(env, source, target)
+        return original_shared(target, source, env)
+
+    def static_emitter(target, source, env):
+        DoIWYU(env, source, target)
+        return original_static(target, source, env)
+
+    SCons.Defaults.SharedObjectEmitter = shared_emitter
+    SCons.Defaults.StaticObjectEmitter = static_emitter
+
+    def emitter(target, source, env):
+        env.Depends(target, env['IWYU_MAPPING_FILE'])
+        env.Depends(target, env['IWYU_MASSAGE'])
+        return target, source
+
+    def _concat_list(prefixes, list, suffixes, env, f=lambda x: x, target=None, source=None):
+        """ Creates a new list from 'list' by first interpolating each element
+            in the list using the 'env' dictionary and then calling f on the
+            list, and concatenate the 'prefix' and 'suffix' LISTS onto each element of the list.
+            A trailing space on the last element of 'prefix' or leading space on the
+            first element of 'suffix' will cause them to be put into separate list
+            elements rather than being concatenated.
+        """
+
+        if not list:
+            return list
+
+        l = f(SCons.PathList.PathList(list).subst_path(env, target, source))
+        if l is not None:
+            list = l
+
+        # This bit replaces current concat_ixes
+
+        result = []
+
+        def process_stringlist(s):
+            return [ str(env.subst(p, SCons.Subst.SUBST_RAW))
+                                              for p in Flatten([s]) if p != '' ]
+
+        # ensure that prefix and suffix are strings
+        prefixes = process_stringlist(prefixes)
+        prefix = ''
+        if len(prefixes) != 0:
+            if prefixes[-1][-1] != ' ':
+                prefix = prefixes.pop()
+
+        suffixes = process_stringlist(suffixes)
+        suffix = ''
+        if len(suffixes) != 0:
+            if suffixes[-1][0] != ' ':
+                suffix = suffixes.pop(0)
+
+        for x in list:
+            if isinstance(x, SCons.Node.FS.File):
+                result.append(x)
+                continue
+            x = str(x)
+            if x:
+                result.append(prefixes)
+                if prefix:
+                    if x[:len(prefix)] != prefix:
+                        x = prefix + x
+                result.append(x)
+                if suffix:
+                    if x[-len(suffix):] != suffix:
+                        result[-1] = result[-1] + suffix
+                result.append(suffixes)
+        return result
+
+    env['_concat_list'] = _concat_list
+    # Note to self: command 2>&1 | other command appears to work as I would hope
+    # except it eats errors
+    iwyu = SCons.Builder.Builder(
+           action=[
+                '$IWYU_MASSAGE $TARGET $IWYU $IWYU_FLAGS $IWYU_MAPPINGS $IWYU_COMCOM $SOURCE'
+            ],
+            emitter=emitter,
+            suffix='.iwyu',
+            src_suffix='.cpp')
+
+    env.Append(BUILDERS={'IWYU': iwyu})
+
+    # Sigh - IWYU is a right bum as it doesn't recognise /I so I have to
+    # duplicate most of the usual stuff
+
+    env['IWYU_FLAGS'] = [
+        # This might turn down the output a bit. I hope
+        '-Xiwyu', '--transitive_includes_only',
+        # Seem to be needed for a windows build
+        '-D_MT', '-D_DLL', '-m32',
+        # This is something to do with clang, windows and boost headers
+        '-DBOOST_USE_WINDOWS_H',
+        # There's a lot of this, disabled for now
+        '-Wno-inconsistent-missing-override',
+        # Mark boost and Qt headers as system headers to disable a lot of noise.
+        # I'm sure there has to be a better way than saying 'prefix=Q'
+        '--system-header-prefix=Q',
+        '--system-header-prefix=boost/',
+        # Should be able to get this info from our setup really
+        '-fmsc-version=1800', '-D_MSC_VER=1800',
+        # clang and qt don't agree about these because clang says its gcc 4.2
+        # and QT doesn't realise it's clang
+        '-DQ_COMPILER_INITIALIZER_LISTS',
+        '-DQ_COMPILER_DECLTYPE',
+        '-DQ_COMPILER_VARIADIC_TEMPLATES',
+    ]
+    if env['CONFIG'] == 'debug':
+        env['IWYU_FLAGS'] += [ '-D_DEBUG' ]
+
+    env['IWYU_DEFPREFIX'] = '-D'
+    env['IWYU_DEFSUFFIX'] = ''
+    env['IWYU_CPPDEFFLAGS'] = '${_defines(IWYU_DEFPREFIX, CPPDEFINES, IWYU_DEFSUFFIX, __env__)}'
+
+    env['IWYU_INCPREFIX'] = '-I'
+    env['IWYU_INCSUFFIX'] = ''
+    env['IWYU_CPPINCFLAGS'] = '$( ${_concat(IWYU_INCPREFIX, CPPPATH, IWYU_INCSUFFIX, __env__, RDirs, TARGET, SOURCE)} $)'
+
+    env['IWYU_PCH_PREFIX'] = '-include' # Amazingly this works without a space
+    env['IWYU_PCH_SUFFIX'] = ''
+    env['IWYU_PCHFILES'] = '$( ${_concat(IWYU_PCH_PREFIX, PCHSTOP, IWYU_PCH_SUFFIX, __env__, target=TARGET, source=SOURCE)} $)'
+
+    env['IWYU_COMCOM'] = '$IWYU_CPPDEFFLAGS $IWYU_CPPINCFLAGS $IWYU_PCHFILES $CCPDBFLAGS'
+    env['IWYU_MAPPING_PREFIX'] = ['-Xiwyu', '--mapping_file=']
+    env['IWYU_MAPPING_SUFFIX'] = ''
+    env['IWYU_MAPPINGS'] = '$( ${_concat_list(IWYU_MAPPING_PREFIX, IWYU_MAPPING_FILE, IWYU_MAPPING_SUFFIX, __env__, f=lambda l: [ str(x) for x in l], target=TARGET, source=SOURCE)} $)'
+
+    env['IWYU_MAPPING_FILE'] = [
+        env.File('#/modorganizer/qt5_4.imp'),
+        env.File('#/modorganizer/win.imp'),
+        env.File('#/modorganizer/mappings.imp')
+        ]
+
+    env['IWYU_MASSAGE'] = env.File('#/modorganizer/massage_messages.py')
 
 # Create base environment
 vars = setup_config_variables()
@@ -347,6 +512,11 @@ else:
     env.AppendUnique(CPPFLAGS = [ '/O2', '/MD' ])
     env.AppendUnique(LINKFLAGS = [ '/OPT:REF', '/OPT:ICF' ])
 
+# Set up include what you use. Add this as an extra compile step. Note it
+# doesn't currently generate an output file (use the output instead!).
+if 'IWYU' in env:
+    setup_IWYU(env)
+
 # /OPT:REF removes unreferenced code
 # for release, use /OPT:ICF (comdat folding: coalesce identical blocks of code)
 
diff --git a/mappings.imp b/mappings.imp
new file mode 100644
index 00000000..6af65e3c
--- /dev/null
+++ b/mappings.imp
@@ -0,0 +1,30 @@
+[
+
+# for boost???
+# These are probably correct but might need a revisit as if you look at the boost documentation pages, it
+# can give you huge lists of alternate includes...
+    { symbol: [ "BOOST_FOREACH",                            "private", "<boost/foreach.hpp>", "public" ] },
+
+    { include: [ "@\"boost/bind/.*\"",                      "private", "<boost/bind.hpp>", "public" ] },
+    { include: [ "@\"boost/algorithm/string/.*\"",          "private", "<boost/algorithm/string.hpp>", "public" ] },
+    { include: [ "@\"boost/assign/.*\"",                    "private", "<boost/assign.hpp>", "public" ] },
+    { include: [ "@\"boost/filesystem/.*\"",                "private", "<boost/filesystem.hpp>", "public" ] },
+    { include: [ "@\"boost/format/.*\"",                    "private", "<boost/format.hpp>", "public" ] },
+    { include: [ "@\"boost/function/.*\"",                  "private", "<boost/function.hpp>", "public" ] },
+    { include: [ "@\"boost/local/.*\"",                     "private", "<boost/locale.hpp>", "public" ] },
+    { include: [ "@\"boost/python/.*\"",                    "private", "<boost/python.hpp>", "public" ] },
+    { include: [ "@\"boost/signals2/.*\"",                  "private", "<boost/signals2.hpp>", "public" ] },
+    { include: [ "\"boost/smart_ptr/scoped_array.hpp\"",    "private", "<boost/scoped_array.hpp>", "public" ] },
+    { include: [ "\"boost/smart_ptr/shared_ptr.hpp\"",      "private", "<boost/shared_ptr.hpp>", "public" ] },
+    # this appears to be excessive
+    #{ include: [ "@\"boost/thread/.*\"",                    "private", "<boost/thread.hpp>", "public" ] },
+
+# And this is specific to us
+    { include: [ "\"appconfig.inc\"", "private", "\"appconfig.h\"", "public" ] },
+
+]
+
+# Ones I don't yet know how to deal with
+#include "boost/fusion/container/vector/vector10_fwd.hpp"  // for fusion
+#include "boost/iterator/iterator_facade.hpp"  // for operator!=
+#include "boost/iterator/iterator_facade.hpp"
diff --git a/massage_messages.py b/massage_messages.py
new file mode 100644
index 00000000..249068ba
--- /dev/null
+++ b/massage_messages.py
@@ -0,0 +1,116 @@
+import fileinput
+import re
+import subprocess
+import sys
+
+
+"""
+
+source/organizer/aboutdialog.h should add these lines:
+#include <QObject>  // for Q_OBJECT, slots
+#include <QString>  // for QString
+class QListWidgetItem;
+class QWidget;
+
+source/organizer/aboutdialog.h should remove these lines:
+- #include <QListWidgetItem>  // lines 25-25
+- #include <utility>  // lines 28-28
+- #include <vector>  // lines 27-27
+- class DownloadManager;  // lines 47-47
+
+The full include-list for source/organizer/aboutdialog.h:
+#include <QDialog>  // for QDialog
+#include <QObject>  // for Q_OBJECT, slots
+#include <QString>  // for QString
+#include <map>      // for map
+class QListWidgetItem;
+class QWidget;
+namespace Ui { class AboutDialog; }  // lines 31-31
+---
+"""
+removing = None
+
+includes = dict
+
+foundline = 0
+
+errors = False
+
+def process_next_line(line, outfile):
+    """ Read a line of output/error from include-what-you use
+        Turn clang errors into a form QT creator recognises
+        Raise warnings for unneeded includes
+    """
+    global removing
+    global includes
+    global foundline
+    global errors
+    line = line.rstrip()
+    print >> outfile, line
+    if removing:
+        if line == '':
+            removing = None
+            print
+            return
+        else:
+            # Really we should stash these so that if we get a 'class xxx' in
+            # the add lines we can print it here. also we could do the case
+            # fixing.
+            m = re.match(r'- #include [<"](.*)[">] +// lines (.*)-', line)
+            if m:
+                # If there is an added line with the same class, print it here
+                print '%s(%s) : warning I0001: Unnecessary include of %s' %\
+                                              (removing, m.group(2), m.group(1))
+                foundline = m.group(1)
+            else:
+                m = re.match(r'- (.*) +// lines (.*)-', line)
+                if m:
+                    print '%s(%s) : warning I0002: '\
+                                              'Unnecessary forward ref of %s' %\
+                                              (removing, m.group(2), m.group(1))
+                    foundline = m.group(1)
+                else:
+                    print '********* I got confused **********'
+
+    if line.startswith('In file included from'):
+        line = re.sub(r'^(In file included from)(.*):(\d+):',
+                      r'        \2(\3) : \1 here',
+                      line)
+        # Note; QT Creator seems to be unwilling to let you double click the
+        # line to select the code in question if you get a string of these, not
+        # sure why.
+    elif ': note:' in line:
+        line = '        ' + re.sub(r':(\d+):\d+: note:', r'(\1) : note:', line)
+    else:
+        # Replace clang :line:column: type: with ms (line) : type nnnn:
+        line = re.sub(r':(\d+):\d+: ([^:]*):', r'(\1) : \2 I1234:', line)
+        if ' : error I1234:' in line:
+            errors = True
+
+    print line
+    if line.endswith(' should remove these lines:'):
+        removing = (line.split(' '))[0]
+    elif line.endswith(' should add these lines:'):
+        adding = (line.split(' '))[0]
+
+# also process the other lines
+
+    # added lines should come after the first entry with a line number.
+
+outfile = open(sys.argv[1], 'w')
+process = subprocess.Popen(sys.argv[2:],
+                           stdout = subprocess.PIPE, stderr = subprocess.STDOUT)
+while True:
+    output = process.stdout.readline()
+    if output == '' and process.poll() is not None:
+        break
+    if output:
+        process_next_line(output, outfile)
+
+rc = process.poll()
+# The return code you get appears to be more to do with the amount of output
+# generated than any real error, so instead we should error if any ': error:'
+# lines are detected
+
+if errors:
+    sys.exit(1)
diff --git a/qt5_4.imp b/qt5_4.imp
new file mode 100644
index 00000000..22553b0e
--- /dev/null
+++ b/qt5_4.imp
@@ -0,0 +1,2478 @@
+[
+
+# Per le documentation, each class lives in it's own header file. These are the
+# official header files (as far as I can determine, from a scan of the QT includes
+# directory)
+# It'd be nice if IWYU could be told to recognise X::y as coming from the same header as X
+
+    { symbol: [ "ActiveQt", "private", "<ActiveQt>", "public" ] },
+    { symbol: [ "ActiveQtDepends", "private", "<ActiveQtDepends>", "public" ] },
+    { symbol: [ "ActiveQtVersion", "private", "<ActiveQtVersion>", "public" ] },
+    { symbol: [ "Enginio", "private", "<Enginio>", "public" ] },
+    { symbol: [ "EnginioDepends", "private", "<EnginioDepends>", "public" ] },
+    { symbol: [ "EnginioVersion", "private", "<EnginioVersion>", "public" ] },
+    { symbol: [ "QAbstractAnimation", "private", "<QAbstractAnimation>", "public" ] },
+    { symbol: [ "QAbstractAudioDeviceInfo", "private", "<QAbstractAudioDeviceInfo>", "public" ] },
+    { symbol: [ "QAbstractAudioInput", "private", "<QAbstractAudioInput>", "public" ] },
+    { symbol: [ "QAbstractAudioOutput", "private", "<QAbstractAudioOutput>", "public" ] },
+    { symbol: [ "QAbstractButton", "private", "<QAbstractButton>", "public" ] },
+    { symbol: [ "QAbstractEventDispatcher", "private", "<QAbstractEventDispatcher>", "public" ] },
+    { symbol: [ "QAbstractExtensionFactory", "private", "<QAbstractExtensionFactory>", "public" ] },
+    { symbol: [ "QAbstractExtensionManager", "private", "<QAbstractExtensionManager>", "public" ] },
+    { symbol: [ "QAbstractFormBuilder", "private", "<QAbstractFormBuilder>", "public" ] },
+    { symbol: [ "QAbstractGraphicsShapeItem", "private", "<QAbstractGraphicsShapeItem>", "public" ] },
+    { symbol: [ "QAbstractItemDelegate", "private", "<QAbstractItemDelegate>", "public" ] },
+    { symbol: [ "QAbstractItemModel", "private", "<QAbstractItemModel>", "public" ] },
+    { symbol: [ "QAbstractItemView", "private", "<QAbstractItemView>", "public" ] },
+    { symbol: [ "QAbstractListModel", "private", "<QAbstractListModel>", "public" ] },
+    { symbol: [ "QAbstractMessageHandler", "private", "<QAbstractMessageHandler>", "public" ] },
+    { symbol: [ "QAbstractNativeEventFilter", "private", "<QAbstractNativeEventFilter>", "public" ] },
+    { symbol: [ "QAbstractNetworkCache", "private", "<QAbstractNetworkCache>", "public" ] },
+    { symbol: [ "QAbstractPlanarVideoBuffer", "private", "<QAbstractPlanarVideoBuffer>", "public" ] },
+    { symbol: [ "QAbstractPrintDialog", "private", "<QAbstractPrintDialog>", "public" ] },
+    { symbol: [ "QAbstractProxyModel", "private", "<QAbstractProxyModel>", "public" ] },
+    { symbol: [ "QAbstractScrollArea", "private", "<QAbstractScrollArea>", "public" ] },
+    { symbol: [ "QAbstractSlider", "private", "<QAbstractSlider>", "public" ] },
+    { symbol: [ "QAbstractSocket", "private", "<QAbstractSocket>", "public" ] },
+    { symbol: [ "QAbstractSpinBox", "private", "<QAbstractSpinBox>", "public" ] },
+    { symbol: [ "QAbstractState", "private", "<QAbstractState>", "public" ] },
+    { symbol: [ "QAbstractTableModel", "private", "<QAbstractTableModel>", "public" ] },
+    { symbol: [ "QAbstractTextDocumentLayout", "private", "<QAbstractTextDocumentLayout>", "public" ] },
+    { symbol: [ "QAbstractTransition", "private", "<QAbstractTransition>", "public" ] },
+    { symbol: [ "QAbstractUndoItem", "private", "<QAbstractUndoItem>", "public" ] },
+    { symbol: [ "QAbstractUriResolver", "private", "<QAbstractUriResolver>", "public" ] },
+    { symbol: [ "QAbstractVideoBuffer", "private", "<QAbstractVideoBuffer>", "public" ] },
+    { symbol: [ "QAbstractVideoSurface", "private", "<QAbstractVideoSurface>", "public" ] },
+    { symbol: [ "QAbstractXmlNodeModel", "private", "<QAbstractXmlNodeModel>", "public" ] },
+    { symbol: [ "QAbstractXmlReceiver", "private", "<QAbstractXmlReceiver>", "public" ] },
+    { symbol: [ "QAccelerometer", "private", "<QAccelerometer>", "public" ] },
+    { symbol: [ "QAccelerometerFilter", "private", "<QAccelerometerFilter>", "public" ] },
+    { symbol: [ "QAccelerometerReading", "private", "<QAccelerometerReading>", "public" ] },
+    { symbol: [ "QAccessible", "private", "<QAccessible>", "public" ] },
+    { symbol: [ "QAccessibleAbstractScrollArea", "private", "<QAccessibleAbstractScrollArea>", "public" ] },
+    { symbol: [ "QAccessibleAbstractSlider", "private", "<QAccessibleAbstractSlider>", "public" ] },
+    { symbol: [ "QAccessibleAbstractSpinBox", "private", "<QAccessibleAbstractSpinBox>", "public" ] },
+    { symbol: [ "QAccessibleActionInterface", "private", "<QAccessibleActionInterface>", "public" ] },
+    { symbol: [ "QAccessibleApplication", "private", "<QAccessibleApplication>", "public" ] },
+    { symbol: [ "QAccessibleBridge", "private", "<QAccessibleBridge>", "public" ] },
+    { symbol: [ "QAccessibleBridgePlugin", "private", "<QAccessibleBridgePlugin>", "public" ] },
+    { symbol: [ "QAccessibleButton", "private", "<QAccessibleButton>", "public" ] },
+    { symbol: [ "QAccessibleCalendarWidget", "private", "<QAccessibleCalendarWidget>", "public" ] },
+    { symbol: [ "QAccessibleComboBox", "private", "<QAccessibleComboBox>", "public" ] },
+    { symbol: [ "QAccessibleDial", "private", "<QAccessibleDial>", "public" ] },
+    { symbol: [ "QAccessibleDialogButtonBox", "private", "<QAccessibleDialogButtonBox>", "public" ] },
+    { symbol: [ "QAccessibleDisplay", "private", "<QAccessibleDisplay>", "public" ] },
+    { symbol: [ "QAccessibleDockWidget", "private", "<QAccessibleDockWidget>", "public" ] },
+    { symbol: [ "QAccessibleDoubleSpinBox", "private", "<QAccessibleDoubleSpinBox>", "public" ] },
+    { symbol: [ "QAccessibleEditableTextInterface", "private", "<QAccessibleEditableTextInterface>", "public" ] },
+    { symbol: [ "QAccessibleEvent", "private", "<QAccessibleEvent>", "public" ] },
+    { symbol: [ "QAccessibleGroupBox", "private", "<QAccessibleGroupBox>", "public" ] },
+    { symbol: [ "QAccessibleImageInterface", "private", "<QAccessibleImageInterface>", "public" ] },
+    { symbol: [ "QAccessibleInterface", "private", "<QAccessibleInterface>", "public" ] },
+    { symbol: [ "QAccessibleLineEdit", "private", "<QAccessibleLineEdit>", "public" ] },
+    { symbol: [ "QAccessibleMainWindow", "private", "<QAccessibleMainWindow>", "public" ] },
+    { symbol: [ "QAccessibleMdiArea", "private", "<QAccessibleMdiArea>", "public" ] },
+    { symbol: [ "QAccessibleMdiSubWindow", "private", "<QAccessibleMdiSubWindow>", "public" ] },
+    { symbol: [ "QAccessibleMenu", "private", "<QAccessibleMenu>", "public" ] },
+    { symbol: [ "QAccessibleMenuBar", "private", "<QAccessibleMenuBar>", "public" ] },
+    { symbol: [ "QAccessibleMenuItem", "private", "<QAccessibleMenuItem>", "public" ] },
+    { symbol: [ "QAccessibleObject", "private", "<QAccessibleObject>", "public" ] },
+    { symbol: [ "QAccessiblePlainTextEdit", "private", "<QAccessiblePlainTextEdit>", "public" ] },
+    { symbol: [ "QAccessiblePlugin", "private", "<QAccessiblePlugin>", "public" ] },
+    { symbol: [ "QAccessibleProgressBar", "private", "<QAccessibleProgressBar>", "public" ] },
+    { symbol: [ "QAccessibleScrollArea", "private", "<QAccessibleScrollArea>", "public" ] },
+    { symbol: [ "QAccessibleScrollBar", "private", "<QAccessibleScrollBar>", "public" ] },
+    { symbol: [ "QAccessibleSlider", "private", "<QAccessibleSlider>", "public" ] },
+    { symbol: [ "QAccessibleSpinBox", "private", "<QAccessibleSpinBox>", "public" ] },
+    { symbol: [ "QAccessibleStackedWidget", "private", "<QAccessibleStackedWidget>", "public" ] },
+    { symbol: [ "QAccessibleStateChangeEvent", "private", "<QAccessibleStateChangeEvent>", "public" ] },
+    { symbol: [ "QAccessibleTabBar", "private", "<QAccessibleTabBar>", "public" ] },
+    { symbol: [ "QAccessibleTable", "private", "<QAccessibleTable>", "public" ] },
+    { symbol: [ "QAccessibleTableCell", "private", "<QAccessibleTableCell>", "public" ] },
+    { symbol: [ "QAccessibleTableCellInterface", "private", "<QAccessibleTableCellInterface>", "public" ] },
+    { symbol: [ "QAccessibleTableCornerButton", "private", "<QAccessibleTableCornerButton>", "public" ] },
+    { symbol: [ "QAccessibleTableHeaderCell", "private", "<QAccessibleTableHeaderCell>", "public" ] },
+    { symbol: [ "QAccessibleTableInterface", "private", "<QAccessibleTableInterface>", "public" ] },
+    { symbol: [ "QAccessibleTableModelChangeEvent", "private", "<QAccessibleTableModelChangeEvent>", "public" ] },
+    { symbol: [ "QAccessibleTextBrowser", "private", "<QAccessibleTextBrowser>", "public" ] },
+    { symbol: [ "QAccessibleTextCursorEvent", "private", "<QAccessibleTextCursorEvent>", "public" ] },
+    { symbol: [ "QAccessibleTextEdit", "private", "<QAccessibleTextEdit>", "public" ] },
+    { symbol: [ "QAccessibleTextInsertEvent", "private", "<QAccessibleTextInsertEvent>", "public" ] },
+    { symbol: [ "QAccessibleTextInterface", "private", "<QAccessibleTextInterface>", "public" ] },
+    { symbol: [ "QAccessibleTextRemoveEvent", "private", "<QAccessibleTextRemoveEvent>", "public" ] },
+    { symbol: [ "QAccessibleTextSelectionEvent", "private", "<QAccessibleTextSelectionEvent>", "public" ] },
+    { symbol: [ "QAccessibleTextUpdateEvent", "private", "<QAccessibleTextUpdateEvent>", "public" ] },
+    { symbol: [ "QAccessibleTextWidget", "private", "<QAccessibleTextWidget>", "public" ] },
+    { symbol: [ "QAccessibleToolBox", "private", "<QAccessibleToolBox>", "public" ] },
+    { symbol: [ "QAccessibleToolButton", "private", "<QAccessibleToolButton>", "public" ] },
+    { symbol: [ "QAccessibleTree", "private", "<QAccessibleTree>", "public" ] },
+    { symbol: [ "QAccessibleValueChangeEvent", "private", "<QAccessibleValueChangeEvent>", "public" ] },
+    { symbol: [ "QAccessibleValueInterface", "private", "<QAccessibleValueInterface>", "public" ] },
+    { symbol: [ "QAccessibleWidget", "private", "<QAccessibleWidget>", "public" ] },
+    { symbol: [ "QAccessibleWindowContainer", "private", "<QAccessibleWindowContainer>", "public" ] },
+    { symbol: [ "QAction", "private", "<QAction>", "public" ] },
+    { symbol: [ "QActionEvent", "private", "<QActionEvent>", "public" ] },
+    { symbol: [ "QActionGroup", "private", "<QActionGroup>", "public" ] },
+    { symbol: [ "QAltimeter", "private", "<QAltimeter>", "public" ] },
+    { symbol: [ "QAltimeterFilter", "private", "<QAltimeterFilter>", "public" ] },
+    { symbol: [ "QAltimeterReading", "private", "<QAltimeterReading>", "public" ] },
+    { symbol: [ "QAmbientLightFilter", "private", "<QAmbientLightFilter>", "public" ] },
+    { symbol: [ "QAmbientLightReading", "private", "<QAmbientLightReading>", "public" ] },
+    { symbol: [ "QAmbientLightSensor", "private", "<QAmbientLightSensor>", "public" ] },
+    { symbol: [ "QAmbientTemperatureFilter", "private", "<QAmbientTemperatureFilter>", "public" ] },
+    { symbol: [ "QAmbientTemperatureReading", "private", "<QAmbientTemperatureReading>", "public" ] },
+    { symbol: [ "QAmbientTemperatureSensor", "private", "<QAmbientTemperatureSensor>", "public" ] },
+    { symbol: [ "QAnimationDriver", "private", "<QAnimationDriver>", "public" ] },
+    { symbol: [ "QAnimationGroup", "private", "<QAnimationGroup>", "public" ] },
+    { symbol: [ "QApplication", "private", "<QApplication>", "public" ] },
+    { symbol: [ "QApplicationStateChangeEvent", "private", "<QApplicationStateChangeEvent>", "public" ] },
+    { symbol: [ "QArgument", "private", "<QArgument>", "public" ] },
+    { symbol: [ "QArrayData", "private", "<QArrayData>", "public" ] },
+    { symbol: [ "QArrayDataPointer", "private", "<QArrayDataPointer>", "public" ] },
+    { symbol: [ "QArrayDataPointerRef", "private", "<QArrayDataPointerRef>", "public" ] },
+    { symbol: [ "QAssociativeIterable", "private", "<QAssociativeIterable>", "public" ] },
+    { symbol: [ "QAtomicInt", "private", "<QAtomicInt>", "public" ] },
+    { symbol: [ "QAtomicInteger", "private", "<QAtomicInteger>", "public" ] },
+    { symbol: [ "QAtomicPointer", "private", "<QAtomicPointer>", "public" ] },
+    { symbol: [ "QAudio", "private", "<QAudio>", "public" ] },
+    { symbol: [ "QAudioBuffer", "private", "<QAudioBuffer>", "public" ] },
+    { symbol: [ "QAudioDecoder", "private", "<QAudioDecoder>", "public" ] },
+    { symbol: [ "QAudioDecoderControl", "private", "<QAudioDecoderControl>", "public" ] },
+    { symbol: [ "QAudioDeviceInfo", "private", "<QAudioDeviceInfo>", "public" ] },
+    { symbol: [ "QAudioEncoderSettings", "private", "<QAudioEncoderSettings>", "public" ] },
+    { symbol: [ "QAudioEncoderSettingsControl", "private", "<QAudioEncoderSettingsControl>", "public" ] },
+    { symbol: [ "QAudioFormat", "private", "<QAudioFormat>", "public" ] },
+    { symbol: [ "QAudioInput", "private", "<QAudioInput>", "public" ] },
+    { symbol: [ "QAudioInputSelectorControl", "private", "<QAudioInputSelectorControl>", "public" ] },
+    { symbol: [ "QAudioOutput", "private", "<QAudioOutput>", "public" ] },
+    { symbol: [ "QAudioOutputSelectorControl", "private", "<QAudioOutputSelectorControl>", "public" ] },
+    { symbol: [ "QAudioProbe", "private", "<QAudioProbe>", "public" ] },
+    { symbol: [ "QAudioRecorder", "private", "<QAudioRecorder>", "public" ] },
+    { symbol: [ "QAudioSystemFactoryInterface", "private", "<QAudioSystemFactoryInterface>", "public" ] },
+    { symbol: [ "QAudioSystemPlugin", "private", "<QAudioSystemPlugin>", "public" ] },
+    { symbol: [ "QAuthenticator", "private", "<QAuthenticator>", "public" ] },
+    { symbol: [ "QAxAggregated", "private", "<QAxAggregated>", "public" ] },
+    { symbol: [ "QAxBase", "private", "<QAxBase>", "public" ] },
+    { symbol: [ "QAxBindable", "private", "<QAxBindable>", "public" ] },
+    { symbol: [ "QAxFactory", "private", "<QAxFactory>", "public" ] },
+    { symbol: [ "QAxObject", "private", "<QAxObject>", "public" ] },
+    { symbol: [ "QAxScript", "private", "<QAxScript>", "public" ] },
+    { symbol: [ "QAxScriptEngine", "private", "<QAxScriptEngine>", "public" ] },
+    { symbol: [ "QAxScriptManager", "private", "<QAxScriptManager>", "public" ] },
+    { symbol: [ "QAxSelect", "private", "<QAxSelect>", "public" ] },
+    { symbol: [ "QAxWidget", "private", "<QAxWidget>", "public" ] },
+    { symbol: [ "QBBSystemLocaleData", "private", "<QBBSystemLocaleData>", "public" ] },
+    { symbol: [ "QBackingStore", "private", "<QBackingStore>", "public" ] },
+    { symbol: [ "QBasicMutex", "private", "<QBasicMutex>", "public" ] },
+    { symbol: [ "QBasicTimer", "private", "<QBasicTimer>", "public" ] },
+    { symbol: [ "QBitArray", "private", "<QBitArray>", "public" ] },
+    { symbol: [ "QBitRef", "private", "<QBitRef>", "public" ] },
+    { symbol: [ "QBitmap", "private", "<QBitmap>", "public" ] },
+    { symbol: [ "QBluetoothAddress", "private", "<QBluetoothAddress>", "public" ] },
+    { symbol: [ "QBluetoothDeviceDiscoveryAgent", "private", "<QBluetoothDeviceDiscoveryAgent>", "public" ] },
+    { symbol: [ "QBluetoothDeviceInfo", "private", "<QBluetoothDeviceInfo>", "public" ] },
+    { symbol: [ "QBluetoothHostInfo", "private", "<QBluetoothHostInfo>", "public" ] },
+    { symbol: [ "QBluetoothLocalDevice", "private", "<QBluetoothLocalDevice>", "public" ] },
+    { symbol: [ "QBluetoothServer", "private", "<QBluetoothServer>", "public" ] },
+    { symbol: [ "QBluetoothServiceDiscoveryAgent", "private", "<QBluetoothServiceDiscoveryAgent>", "public" ] },
+    { symbol: [ "QBluetoothServiceInfo", "private", "<QBluetoothServiceInfo>", "public" ] },
+    { symbol: [ "QBluetoothSocket", "private", "<QBluetoothSocket>", "public" ] },
+    { symbol: [ "QBluetoothTransferManager", "private", "<QBluetoothTransferManager>", "public" ] },
+    { symbol: [ "QBluetoothTransferReply", "private", "<QBluetoothTransferReply>", "public" ] },
+    { symbol: [ "QBluetoothTransferRequest", "private", "<QBluetoothTransferRequest>", "public" ] },
+    { symbol: [ "QBluetoothUuid", "private", "<QBluetoothUuid>", "public" ] },
+    { symbol: [ "QBoxLayout", "private", "<QBoxLayout>", "public" ] },
+    { symbol: [ "QBrush", "private", "<QBrush>", "public" ] },
+    { symbol: [ "QBrushData", "private", "<QBrushData>", "public" ] },
+    { symbol: [ "QBuffer", "private", "<QBuffer>", "public" ] },
+    { symbol: [ "QButtonGroup", "private", "<QButtonGroup>", "public" ] },
+    { symbol: [ "QByteArray", "private", "<QByteArray>", "public" ] },
+    { symbol: [ "QByteArrayData", "private", "<QByteArrayData>", "public" ] },
+    { symbol: [ "QByteArrayDataPtr", "private", "<QByteArrayDataPtr>", "public" ] },
+    { symbol: [ "QByteArrayList", "private", "<QByteArrayList>", "public" ] },
+    { symbol: [ "QByteArrayListIterator", "private", "<QByteArrayListIterator>", "public" ] },
+    { symbol: [ "QByteArrayMatcher", "private", "<QByteArrayMatcher>", "public" ] },
+    { symbol: [ "QByteRef", "private", "<QByteRef>", "public" ] },
+    { symbol: [ "QCache", "private", "<QCache>", "public" ] },
+    { symbol: [ "QCalendarWidget", "private", "<QCalendarWidget>", "public" ] },
+    { symbol: [ "QCamera", "private", "<QCamera>", "public" ] },
+    { symbol: [ "QCameraCaptureBufferFormatControl", "private", "<QCameraCaptureBufferFormatControl>", "public" ] },
+    { symbol: [ "QCameraCaptureDestinationControl", "private", "<QCameraCaptureDestinationControl>", "public" ] },
+    { symbol: [ "QCameraControl", "private", "<QCameraControl>", "public" ] },
+    { symbol: [ "QCameraExposure", "private", "<QCameraExposure>", "public" ] },
+    { symbol: [ "QCameraExposureControl", "private", "<QCameraExposureControl>", "public" ] },
+    { symbol: [ "QCameraFeedbackControl", "private", "<QCameraFeedbackControl>", "public" ] },
+    { symbol: [ "QCameraFlashControl", "private", "<QCameraFlashControl>", "public" ] },
+    { symbol: [ "QCameraFocus", "private", "<QCameraFocus>", "public" ] },
+    { symbol: [ "QCameraFocusControl", "private", "<QCameraFocusControl>", "public" ] },
+    { symbol: [ "QCameraFocusZone", "private", "<QCameraFocusZone>", "public" ] },
+    { symbol: [ "QCameraFocusZoneList", "private", "<QCameraFocusZoneList>", "public" ] },
+    { symbol: [ "QCameraImageCapture", "private", "<QCameraImageCapture>", "public" ] },
+    { symbol: [ "QCameraImageCaptureControl", "private", "<QCameraImageCaptureControl>", "public" ] },
+    { symbol: [ "QCameraImageProcessing", "private", "<QCameraImageProcessing>", "public" ] },
+    { symbol: [ "QCameraImageProcessingControl", "private", "<QCameraImageProcessingControl>", "public" ] },
+    { symbol: [ "QCameraInfo", "private", "<QCameraInfo>", "public" ] },
+    { symbol: [ "QCameraInfoControl", "private", "<QCameraInfoControl>", "public" ] },
+    { symbol: [ "QCameraLocksControl", "private", "<QCameraLocksControl>", "public" ] },
+    { symbol: [ "QCameraViewfinder", "private", "<QCameraViewfinder>", "public" ] },
+    { symbol: [ "QCameraViewfinderSettingsControl", "private", "<QCameraViewfinderSettingsControl>", "public" ] },
+    { symbol: [ "QCameraZoomControl", "private", "<QCameraZoomControl>", "public" ] },
+    { symbol: [ "QChar", "private", "<QChar>", "public" ] },
+    { symbol: [ "QCharRef", "private", "<QCharRef>", "public" ] },
+    { symbol: [ "QCheckBox", "private", "<QCheckBox>", "public" ] },
+    { symbol: [ "QChildEvent", "private", "<QChildEvent>", "public" ] },
+    { symbol: [ "QClipboard", "private", "<QClipboard>", "public" ] },
+    { symbol: [ "QCloseEvent", "private", "<QCloseEvent>", "public" ] },
+    { symbol: [ "QCocoaNativeContext", "private", "<QCocoaNativeContext>", "public" ] },
+    { symbol: [ "QCollator", "private", "<QCollator>", "public" ] },
+    { symbol: [ "QCollatorSortKey", "private", "<QCollatorSortKey>", "public" ] },
+    { symbol: [ "QColor", "private", "<QColor>", "public" ] },
+    { symbol: [ "QColorDialog", "private", "<QColorDialog>", "public" ] },
+    { symbol: [ "QColormap", "private", "<QColormap>", "public" ] },
+    { symbol: [ "QColumnView", "private", "<QColumnView>", "public" ] },
+    { symbol: [ "QComboBox", "private", "<QComboBox>", "public" ] },
+    { symbol: [ "QCommandLineOption", "private", "<QCommandLineOption>", "public" ] },
+    { symbol: [ "QCommandLineParser", "private", "<QCommandLineParser>", "public" ] },
+    { symbol: [ "QCommandLinkButton", "private", "<QCommandLinkButton>", "public" ] },
+    { symbol: [ "QCommonStyle", "private", "<QCommonStyle>", "public" ] },
+    { symbol: [ "QCompass", "private", "<QCompass>", "public" ] },
+    { symbol: [ "QCompassFilter", "private", "<QCompassFilter>", "public" ] },
+    { symbol: [ "QCompassReading", "private", "<QCompassReading>", "public" ] },
+    { symbol: [ "QCompleter", "private", "<QCompleter>", "public" ] },
+    { symbol: [ "QConicalGradient", "private", "<QConicalGradient>", "public" ] },
+    { symbol: [ "QContextMenuEvent", "private", "<QContextMenuEvent>", "public" ] },
+    { symbol: [ "QContiguousCache", "private", "<QContiguousCache>", "public" ] },
+    { symbol: [ "QContiguousCacheData", "private", "<QContiguousCacheData>", "public" ] },
+    { symbol: [ "QContiguousCacheTypedData", "private", "<QContiguousCacheTypedData>", "public" ] },
+    { symbol: [ "QCoreApplication", "private", "<QCoreApplication>", "public" ] },
+    { symbol: [ "QCryptographicHash", "private", "<QCryptographicHash>", "public" ] },
+    { symbol: [ "QCursor", "private", "<QCursor>", "public" ] },
+    { symbol: [ "QDBusAbstractAdaptor", "private", "<QDBusAbstractAdaptor>", "public" ] },
+    { symbol: [ "QDBusAbstractInterface", "private", "<QDBusAbstractInterface>", "public" ] },
+    { symbol: [ "QDBusAbstractInterfaceBase", "private", "<QDBusAbstractInterfaceBase>", "public" ] },
+    { symbol: [ "QDBusArgument", "private", "<QDBusArgument>", "public" ] },
+    { symbol: [ "QDBusConnection", "private", "<QDBusConnection>", "public" ] },
+    { symbol: [ "QDBusConnectionInterface", "private", "<QDBusConnectionInterface>", "public" ] },
+    { symbol: [ "QDBusContext", "private", "<QDBusContext>", "public" ] },
+    { symbol: [ "QDBusError", "private", "<QDBusError>", "public" ] },
+    { symbol: [ "QDBusInterface", "private", "<QDBusInterface>", "public" ] },
+    { symbol: [ "QDBusMessage", "private", "<QDBusMessage>", "public" ] },
+    { symbol: [ "QDBusMetaType", "private", "<QDBusMetaType>", "public" ] },
+    { symbol: [ "QDBusObjectPath", "private", "<QDBusObjectPath>", "public" ] },
+    { symbol: [ "QDBusPendingCall", "private", "<QDBusPendingCall>", "public" ] },
+    { symbol: [ "QDBusPendingCallWatcher", "private", "<QDBusPendingCallWatcher>", "public" ] },
+    { symbol: [ "QDBusPendingReply", "private", "<QDBusPendingReply>", "public" ] },
+    { symbol: [ "QDBusPendingReplyData", "private", "<QDBusPendingReplyData>", "public" ] },
+    { symbol: [ "QDBusReply", "private", "<QDBusReply>", "public" ] },
+    { symbol: [ "QDBusServer", "private", "<QDBusServer>", "public" ] },
+    { symbol: [ "QDBusServiceWatcher", "private", "<QDBusServiceWatcher>", "public" ] },
+    { symbol: [ "QDBusSignature", "private", "<QDBusSignature>", "public" ] },
+    { symbol: [ "QDBusUnixFileDescriptor", "private", "<QDBusUnixFileDescriptor>", "public" ] },
+    { symbol: [ "QDBusVariant", "private", "<QDBusVariant>", "public" ] },
+    { symbol: [ "QDBusVirtualObject", "private", "<QDBusVirtualObject>", "public" ] },
+    { symbol: [ "QDataStream", "private", "<QDataStream>", "public" ] },
+    { symbol: [ "QDataWidgetMapper", "private", "<QDataWidgetMapper>", "public" ] },
+    { symbol: [ "QDate", "private", "<QDate>", "public" ] },
+    { symbol: [ "QDateEdit", "private", "<QDateEdit>", "public" ] },
+    { symbol: [ "QDateTime", "private", "<QDateTime>", "public" ] },
+    { symbol: [ "QDateTimeEdit", "private", "<QDateTimeEdit>", "public" ] },
+    { symbol: [ "QDebug", "private", "<QDebug>", "public" ] },
+    { symbol: [ "QDebugStateSaver", "private", "<QDebugStateSaver>", "public" ] },
+    { symbol: [ "QDeclarativeAttachedPropertiesFunc", "private", "<QDeclarativeAttachedPropertiesFunc>", "public" ] },
+    { symbol: [ "QDeclarativeComponent", "private", "<QDeclarativeComponent>", "public" ] },
+    { symbol: [ "QDeclarativeContext", "private", "<QDeclarativeContext>", "public" ] },
+    { symbol: [ "QDeclarativeDebuggingEnabler", "private", "<QDeclarativeDebuggingEnabler>", "public" ] },
+    { symbol: [ "QDeclarativeEngine", "private", "<QDeclarativeEngine>", "public" ] },
+    { symbol: [ "QDeclarativeError", "private", "<QDeclarativeError>", "public" ] },
+    { symbol: [ "QDeclarativeExpression", "private", "<QDeclarativeExpression>", "public" ] },
+    { symbol: [ "QDeclarativeExtensionInterface", "private", "<QDeclarativeExtensionInterface>", "public" ] },
+    { symbol: [ "QDeclarativeExtensionPlugin", "private", "<QDeclarativeExtensionPlugin>", "public" ] },
+    { symbol: [ "QDeclarativeImageProvider", "private", "<QDeclarativeImageProvider>", "public" ] },
+    { symbol: [ "QDeclarativeInfo", "private", "<QDeclarativeInfo>", "public" ] },
+    { symbol: [ "QDeclarativeItem", "private", "<QDeclarativeItem>", "public" ] },
+    { symbol: [ "QDeclarativeListProperty", "private", "<QDeclarativeListProperty>", "public" ] },
+    { symbol: [ "QDeclarativeListReference", "private", "<QDeclarativeListReference>", "public" ] },
+    { symbol: [ "QDeclarativeNetworkAccessManagerFactory", "private", "<QDeclarativeNetworkAccessManagerFactory>", "public" ] },
+    { symbol: [ "QDeclarativeParserStatus", "private", "<QDeclarativeParserStatus>", "public" ] },
+    { symbol: [ "QDeclarativeProperties", "private", "<QDeclarativeProperties>", "public" ] },
+    { symbol: [ "QDeclarativeProperty", "private", "<QDeclarativeProperty>", "public" ] },
+    { symbol: [ "QDeclarativePropertyMap", "private", "<QDeclarativePropertyMap>", "public" ] },
+    { symbol: [ "QDeclarativePropertyValueInterceptor", "private", "<QDeclarativePropertyValueInterceptor>", "public" ] },
+    { symbol: [ "QDeclarativePropertyValueSource", "private", "<QDeclarativePropertyValueSource>", "public" ] },
+    { symbol: [ "QDeclarativeScriptString", "private", "<QDeclarativeScriptString>", "public" ] },
+    { symbol: [ "QDeclarativeTypeInfo", "private", "<QDeclarativeTypeInfo>", "public" ] },
+    { symbol: [ "QDeclarativeView", "private", "<QDeclarativeView>", "public" ] },
+    { symbol: [ "QDeferredDeleteEvent", "private", "<QDeferredDeleteEvent>", "public" ] },
+    { symbol: [ "QDesignerActionEditorInterface", "private", "<QDesignerActionEditorInterface>", "public" ] },
+    { symbol: [ "QDesignerComponents", "private", "<QDesignerComponents>", "public" ] },
+    { symbol: [ "QDesignerContainerExtension", "private", "<QDesignerContainerExtension>", "public" ] },
+    { symbol: [ "QDesignerCustomWidgetCollectionInterface", "private", "<QDesignerCustomWidgetCollectionInterface>", "public" ] },
+    { symbol: [ "QDesignerCustomWidgetInterface", "private", "<QDesignerCustomWidgetInterface>", "public" ] },
+    { symbol: [ "QDesignerDnDItemInterface", "private", "<QDesignerDnDItemInterface>", "public" ] },
+    { symbol: [ "QDesignerDynamicPropertySheetExtension", "private", "<QDesignerDynamicPropertySheetExtension>", "public" ] },
+    { symbol: [ "QDesignerExportWidget", "private", "<QDesignerExportWidget>", "public" ] },
+    { symbol: [ "QDesignerExtraInfoExtension", "private", "<QDesignerExtraInfoExtension>", "public" ] },
+    { symbol: [ "QDesignerFormEditorInterface", "private", "<QDesignerFormEditorInterface>", "public" ] },
+    { symbol: [ "QDesignerFormEditorPluginInterface", "private", "<QDesignerFormEditorPluginInterface>", "public" ] },
+    { symbol: [ "QDesignerFormWindowCursorInterface", "private", "<QDesignerFormWindowCursorInterface>", "public" ] },
+    { symbol: [ "QDesignerFormWindowInterface", "private", "<QDesignerFormWindowInterface>", "public" ] },
+    { symbol: [ "QDesignerFormWindowManagerInterface", "private", "<QDesignerFormWindowManagerInterface>", "public" ] },
+    { symbol: [ "QDesignerFormWindowToolInterface", "private", "<QDesignerFormWindowToolInterface>", "public" ] },
+    { symbol: [ "QDesignerIntegration", "private", "<QDesignerIntegration>", "public" ] },
+    { symbol: [ "QDesignerIntegrationInterface", "private", "<QDesignerIntegrationInterface>", "public" ] },
+    { symbol: [ "QDesignerLanguageExtension", "private", "<QDesignerLanguageExtension>", "public" ] },
+    { symbol: [ "QDesignerLayoutDecorationExtension", "private", "<QDesignerLayoutDecorationExtension>", "public" ] },
+    { symbol: [ "QDesignerMemberSheetExtension", "private", "<QDesignerMemberSheetExtension>", "public" ] },
+    { symbol: [ "QDesignerMetaDataBaseInterface", "private", "<QDesignerMetaDataBaseInterface>", "public" ] },
+    { symbol: [ "QDesignerMetaDataBaseItemInterface", "private", "<QDesignerMetaDataBaseItemInterface>", "public" ] },
+    { symbol: [ "QDesignerNewFormWidgetInterface", "private", "<QDesignerNewFormWidgetInterface>", "public" ] },
+    { symbol: [ "QDesignerObjectInspectorInterface", "private", "<QDesignerObjectInspectorInterface>", "public" ] },
+    { symbol: [ "QDesignerOptionsPageInterface", "private", "<QDesignerOptionsPageInterface>", "public" ] },
+    { symbol: [ "QDesignerPromotionInterface", "private", "<QDesignerPromotionInterface>", "public" ] },
+    { symbol: [ "QDesignerPropertyEditorInterface", "private", "<QDesignerPropertyEditorInterface>", "public" ] },
+    { symbol: [ "QDesignerPropertySheetExtension", "private", "<QDesignerPropertySheetExtension>", "public" ] },
+    { symbol: [ "QDesignerResourceBrowserInterface", "private", "<QDesignerResourceBrowserInterface>", "public" ] },
+    { symbol: [ "QDesignerSettingsInterface", "private", "<QDesignerSettingsInterface>", "public" ] },
+    { symbol: [ "QDesignerTaskMenuExtension", "private", "<QDesignerTaskMenuExtension>", "public" ] },
+    { symbol: [ "QDesignerWidgetBoxInterface", "private", "<QDesignerWidgetBoxInterface>", "public" ] },
+    { symbol: [ "QDesignerWidgetDataBaseInterface", "private", "<QDesignerWidgetDataBaseInterface>", "public" ] },
+    { symbol: [ "QDesignerWidgetDataBaseItemInterface", "private", "<QDesignerWidgetDataBaseItemInterface>", "public" ] },
+    { symbol: [ "QDesignerWidgetFactoryInterface", "private", "<QDesignerWidgetFactoryInterface>", "public" ] },
+    { symbol: [ "QDesktopServices", "private", "<QDesktopServices>", "public" ] },
+    { symbol: [ "QDesktopWidget", "private", "<QDesktopWidget>", "public" ] },
+    { symbol: [ "QDial", "private", "<QDial>", "public" ] },
+    { symbol: [ "QDialog", "private", "<QDialog>", "public" ] },
+    { symbol: [ "QDialogButtonBox", "private", "<QDialogButtonBox>", "public" ] },
+    { symbol: [ "QDir", "private", "<QDir>", "public" ] },
+    { symbol: [ "QDirIterator", "private", "<QDirIterator>", "public" ] },
+    { symbol: [ "QDirModel", "private", "<QDirModel>", "public" ] },
+    { symbol: [ "QDistanceFilter", "private", "<QDistanceFilter>", "public" ] },
+    { symbol: [ "QDistanceReading", "private", "<QDistanceReading>", "public" ] },
+    { symbol: [ "QDistanceSensor", "private", "<QDistanceSensor>", "public" ] },
+    { symbol: [ "QDnsDomainNameRecord", "private", "<QDnsDomainNameRecord>", "public" ] },
+    { symbol: [ "QDnsHostAddressRecord", "private", "<QDnsHostAddressRecord>", "public" ] },
+    { symbol: [ "QDnsLookup", "private", "<QDnsLookup>", "public" ] },
+    { symbol: [ "QDnsMailExchangeRecord", "private", "<QDnsMailExchangeRecord>", "public" ] },
+    { symbol: [ "QDnsServiceRecord", "private", "<QDnsServiceRecord>", "public" ] },
+    { symbol: [ "QDnsTextRecord", "private", "<QDnsTextRecord>", "public" ] },
+    { symbol: [ "QDockWidget", "private", "<QDockWidget>", "public" ] },
+    { symbol: [ "QDomAttr", "private", "<QDomAttr>", "public" ] },
+    { symbol: [ "QDomCDATASection", "private", "<QDomCDATASection>", "public" ] },
+    { symbol: [ "QDomCharacterData", "private", "<QDomCharacterData>", "public" ] },
+    { symbol: [ "QDomComment", "private", "<QDomComment>", "public" ] },
+    { symbol: [ "QDomDocument", "private", "<QDomDocument>", "public" ] },
+    { symbol: [ "QDomDocumentFragment", "private", "<QDomDocumentFragment>", "public" ] },
+    { symbol: [ "QDomDocumentType", "private", "<QDomDocumentType>", "public" ] },
+    { symbol: [ "QDomElement", "private", "<QDomElement>", "public" ] },
+    { symbol: [ "QDomEntity", "private", "<QDomEntity>", "public" ] },
+    { symbol: [ "QDomEntityReference", "private", "<QDomEntityReference>", "public" ] },
+    { symbol: [ "QDomImplementation", "private", "<QDomImplementation>", "public" ] },
+    { symbol: [ "QDomNamedNodeMap", "private", "<QDomNamedNodeMap>", "public" ] },
+    { symbol: [ "QDomNode", "private", "<QDomNode>", "public" ] },
+    { symbol: [ "QDomNodeList", "private", "<QDomNodeList>", "public" ] },
+    { symbol: [ "QDomNotation", "private", "<QDomNotation>", "public" ] },
+    { symbol: [ "QDomProcessingInstruction", "private", "<QDomProcessingInstruction>", "public" ] },
+    { symbol: [ "QDomText", "private", "<QDomText>", "public" ] },
+    { symbol: [ "QDoubleSpinBox", "private", "<QDoubleSpinBox>", "public" ] },
+    { symbol: [ "QDoubleValidator", "private", "<QDoubleValidator>", "public" ] },
+    { symbol: [ "QDrag", "private", "<QDrag>", "public" ] },
+    { symbol: [ "QDragEnterEvent", "private", "<QDragEnterEvent>", "public" ] },
+    { symbol: [ "QDragLeaveEvent", "private", "<QDragLeaveEvent>", "public" ] },
+    { symbol: [ "QDragMoveEvent", "private", "<QDragMoveEvent>", "public" ] },
+    { symbol: [ "QDropEvent", "private", "<QDropEvent>", "public" ] },
+    { symbol: [ "QDynamicPropertyChangeEvent", "private", "<QDynamicPropertyChangeEvent>", "public" ] },
+    { symbol: [ "QEGLNativeContext", "private", "<QEGLNativeContext>", "public" ] },
+    { symbol: [ "QEasingCurve", "private", "<QEasingCurve>", "public" ] },
+    { symbol: [ "QEglFSFunctions", "private", "<QEglFSFunctions>", "public" ] },
+    { symbol: [ "QElapsedTimer", "private", "<QElapsedTimer>", "public" ] },
+    { symbol: [ "QEnableSharedFromThis", "private", "<QEnableSharedFromThis>", "public" ] },
+    { symbol: [ "QEnterEvent", "private", "<QEnterEvent>", "public" ] },
+    { symbol: [ "QErrorMessage", "private", "<QErrorMessage>", "public" ] },
+    { symbol: [ "QEvent", "private", "<QEvent>", "public" ] },
+    { symbol: [ "QEventLoop", "private", "<QEventLoop>", "public" ] },
+    { symbol: [ "QEventLoopLocker", "private", "<QEventLoopLocker>", "public" ] },
+    { symbol: [ "QEventSizeOfChecker", "private", "<QEventSizeOfChecker>", "public" ] },
+    { symbol: [ "QEventTransition", "private", "<QEventTransition>", "public" ] },
+    { symbol: [ "QException", "private", "<QException>", "public" ] },
+    { symbol: [ "QExplicitlySharedDataPointer", "private", "<QExplicitlySharedDataPointer>", "public" ] },
+    { symbol: [ "QExposeEvent", "private", "<QExposeEvent>", "public" ] },
+    { symbol: [ "QExtensionFactory", "private", "<QExtensionFactory>", "public" ] },
+    { symbol: [ "QExtensionManager", "private", "<QExtensionManager>", "public" ] },
+    { symbol: [ "QFactoryInterface", "private", "<QFactoryInterface>", "public" ] },
+    { symbol: [ "QFile", "private", "<QFile>", "public" ] },
+    { symbol: [ "QFileDevice", "private", "<QFileDevice>", "public" ] },
+    { symbol: [ "QFileDialog", "private", "<QFileDialog>", "public" ] },
+    { symbol: [ "QFileIconProvider", "private", "<QFileIconProvider>", "public" ] },
+    { symbol: [ "QFileInfo", "private", "<QFileInfo>", "public" ] },
+    { symbol: [ "QFileInfoList", "private", "<QFileInfoList>", "public" ] },
+    { symbol: [ "QFileOpenEvent", "private", "<QFileOpenEvent>", "public" ] },
+    { symbol: [ "QFileSelector", "private", "<QFileSelector>", "public" ] },
+    { symbol: [ "QFileSystemModel", "private", "<QFileSystemModel>", "public" ] },
+    { symbol: [ "QFileSystemWatcher", "private", "<QFileSystemWatcher>", "public" ] },
+    { symbol: [ "QFinalState", "private", "<QFinalState>", "public" ] },
+    { symbol: [ "QFlag", "private", "<QFlag>", "public" ] },
+    { symbol: [ "QFlags", "private", "<QFlags>", "public" ] },
+    { symbol: [ "QFocusEvent", "private", "<QFocusEvent>", "public" ] },
+    { symbol: [ "QFocusFrame", "private", "<QFocusFrame>", "public" ] },
+    { symbol: [ "QFont", "private", "<QFont>", "public" ] },
+    { symbol: [ "QFontComboBox", "private", "<QFontComboBox>", "public" ] },
+    { symbol: [ "QFontDatabase", "private", "<QFontDatabase>", "public" ] },
+    { symbol: [ "QFontDialog", "private", "<QFontDialog>", "public" ] },
+    { symbol: [ "QFontInfo", "private", "<QFontInfo>", "public" ] },
+    { symbol: [ "QFontMetrics", "private", "<QFontMetrics>", "public" ] },
+    { symbol: [ "QFontMetricsF", "private", "<QFontMetricsF>", "public" ] },
+    { symbol: [ "QForeachContainer", "private", "<QForeachContainer>", "public" ] },
+    { symbol: [ "QFormBuilder", "private", "<QFormBuilder>", "public" ] },
+    { symbol: [ "QFormLayout", "private", "<QFormLayout>", "public" ] },
+    { symbol: [ "QFrame", "private", "<QFrame>", "public" ] },
+    { symbol: [ "QFunctionPointer", "private", "<QFunctionPointer>", "public" ] },
+    { symbol: [ "QFuture", "private", "<QFuture>", "public" ] },
+    { symbol: [ "QFutureInterface", "private", "<QFutureInterface>", "public" ] },
+    { symbol: [ "QFutureInterfaceBase", "private", "<QFutureInterfaceBase>", "public" ] },
+    { symbol: [ "QFutureIterator", "private", "<QFutureIterator>", "public" ] },
+    { symbol: [ "QFutureSynchronizer", "private", "<QFutureSynchronizer>", "public" ] },
+    { symbol: [ "QFutureWatcher", "private", "<QFutureWatcher>", "public" ] },
+    { symbol: [ "QFutureWatcherBase", "private", "<QFutureWatcherBase>", "public" ] },
+    { symbol: [ "QGL", "private", "<QGL>", "public" ] },
+    { symbol: [ "QGLBuffer", "private", "<QGLBuffer>", "public" ] },
+    { symbol: [ "QGLColormap", "private", "<QGLColormap>", "public" ] },
+    { symbol: [ "QGLContext", "private", "<QGLContext>", "public" ] },
+    { symbol: [ "QGLFormat", "private", "<QGLFormat>", "public" ] },
+    { symbol: [ "QGLFramebufferObject", "private", "<QGLFramebufferObject>", "public" ] },
+    { symbol: [ "QGLFramebufferObjectFormat", "private", "<QGLFramebufferObjectFormat>", "public" ] },
+    { symbol: [ "QGLFunctions", "private", "<QGLFunctions>", "public" ] },
+    { symbol: [ "QGLFunctionsPrivate", "private", "<QGLFunctionsPrivate>", "public" ] },
+    { symbol: [ "QGLPixelBuffer", "private", "<QGLPixelBuffer>", "public" ] },
+    { symbol: [ "QGLShader", "private", "<QGLShader>", "public" ] },
+    { symbol: [ "QGLShaderProgram", "private", "<QGLShaderProgram>", "public" ] },
+    { symbol: [ "QGLWidget", "private", "<QGLWidget>", "public" ] },
+    { symbol: [ "QGLXNativeContext", "private", "<QGLXNativeContext>", "public" ] },
+    { symbol: [ "QGenericArgument", "private", "<QGenericArgument>", "public" ] },
+    { symbol: [ "QGenericMatrix", "private", "<QGenericMatrix>", "public" ] },
+    { symbol: [ "QGenericPlugin", "private", "<QGenericPlugin>", "public" ] },
+    { symbol: [ "QGenericPluginFactory", "private", "<QGenericPluginFactory>", "public" ] },
+    { symbol: [ "QGenericReturnArgument", "private", "<QGenericReturnArgument>", "public" ] },
+    { symbol: [ "QGeoAddress", "private", "<QGeoAddress>", "public" ] },
+    { symbol: [ "QGeoAreaMonitorInfo", "private", "<QGeoAreaMonitorInfo>", "public" ] },
+    { symbol: [ "QGeoAreaMonitorSource", "private", "<QGeoAreaMonitorSource>", "public" ] },
+    { symbol: [ "QGeoCircle", "private", "<QGeoCircle>", "public" ] },
+    { symbol: [ "QGeoCodeReply", "private", "<QGeoCodeReply>", "public" ] },
+    { symbol: [ "QGeoCodingManager", "private", "<QGeoCodingManager>", "public" ] },
+    { symbol: [ "QGeoCodingManagerEngine", "private", "<QGeoCodingManagerEngine>", "public" ] },
+    { symbol: [ "QGeoCoordinate", "private", "<QGeoCoordinate>", "public" ] },
+    { symbol: [ "QGeoLocation", "private", "<QGeoLocation>", "public" ] },
+    { symbol: [ "QGeoManeuver", "private", "<QGeoManeuver>", "public" ] },
+    { symbol: [ "QGeoPositionInfo", "private", "<QGeoPositionInfo>", "public" ] },
+    { symbol: [ "QGeoPositionInfoSource", "private", "<QGeoPositionInfoSource>", "public" ] },
+    { symbol: [ "QGeoPositionInfoSourceFactory", "private", "<QGeoPositionInfoSourceFactory>", "public" ] },
+    { symbol: [ "QGeoRectangle", "private", "<QGeoRectangle>", "public" ] },
+    { symbol: [ "QGeoRoute", "private", "<QGeoRoute>", "public" ] },
+    { symbol: [ "QGeoRouteReply", "private", "<QGeoRouteReply>", "public" ] },
+    { symbol: [ "QGeoRouteRequest", "private", "<QGeoRouteRequest>", "public" ] },
+    { symbol: [ "QGeoRouteSegment", "private", "<QGeoRouteSegment>", "public" ] },
+    { symbol: [ "QGeoRoutingManager", "private", "<QGeoRoutingManager>", "public" ] },
+    { symbol: [ "QGeoRoutingManagerEngine", "private", "<QGeoRoutingManagerEngine>", "public" ] },
+    { symbol: [ "QGeoSatelliteInfo", "private", "<QGeoSatelliteInfo>", "public" ] },
+    { symbol: [ "QGeoSatelliteInfoSource", "private", "<QGeoSatelliteInfoSource>", "public" ] },
+    { symbol: [ "QGeoServiceProvider", "private", "<QGeoServiceProvider>", "public" ] },
+    { symbol: [ "QGeoServiceProviderFactory", "private", "<QGeoServiceProviderFactory>", "public" ] },
+    { symbol: [ "QGeoShape", "private", "<QGeoShape>", "public" ] },
+    { symbol: [ "QGesture", "private", "<QGesture>", "public" ] },
+    { symbol: [ "QGestureEvent", "private", "<QGestureEvent>", "public" ] },
+    { symbol: [ "QGestureRecognizer", "private", "<QGestureRecognizer>", "public" ] },
+    { symbol: [ "QGlobalStatic", "private", "<QGlobalStatic>", "public" ] },
+    { symbol: [ "QGlyphRun", "private", "<QGlyphRun>", "public" ] },
+    { symbol: [ "QGradient", "private", "<QGradient>", "public" ] },
+    { symbol: [ "QGradientStop", "private", "<QGradientStop>", "public" ] },
+    { symbol: [ "QGradientStops", "private", "<QGradientStops>", "public" ] },
+    { symbol: [ "QGraphicsAnchor", "private", "<QGraphicsAnchor>", "public" ] },
+    { symbol: [ "QGraphicsAnchorLayout", "private", "<QGraphicsAnchorLayout>", "public" ] },
+    { symbol: [ "QGraphicsBlurEffect", "private", "<QGraphicsBlurEffect>", "public" ] },
+    { symbol: [ "QGraphicsColorizeEffect", "private", "<QGraphicsColorizeEffect>", "public" ] },
+    { symbol: [ "QGraphicsDropShadowEffect", "private", "<QGraphicsDropShadowEffect>", "public" ] },
+    { symbol: [ "QGraphicsEffect", "private", "<QGraphicsEffect>", "public" ] },
+    { symbol: [ "QGraphicsEllipseItem", "private", "<QGraphicsEllipseItem>", "public" ] },
+    { symbol: [ "QGraphicsGridLayout", "private", "<QGraphicsGridLayout>", "public" ] },
+    { symbol: [ "QGraphicsItem", "private", "<QGraphicsItem>", "public" ] },
+    { symbol: [ "QGraphicsItemAnimation", "private", "<QGraphicsItemAnimation>", "public" ] },
+    { symbol: [ "QGraphicsItemGroup", "private", "<QGraphicsItemGroup>", "public" ] },
+    { symbol: [ "QGraphicsLayout", "private", "<QGraphicsLayout>", "public" ] },
+    { symbol: [ "QGraphicsLayoutItem", "private", "<QGraphicsLayoutItem>", "public" ] },
+    { symbol: [ "QGraphicsLineItem", "private", "<QGraphicsLineItem>", "public" ] },
+    { symbol: [ "QGraphicsLinearLayout", "private", "<QGraphicsLinearLayout>", "public" ] },
+    { symbol: [ "QGraphicsObject", "private", "<QGraphicsObject>", "public" ] },
+    { symbol: [ "QGraphicsOpacityEffect", "private", "<QGraphicsOpacityEffect>", "public" ] },
+    { symbol: [ "QGraphicsPathItem", "private", "<QGraphicsPathItem>", "public" ] },
+    { symbol: [ "QGraphicsPixmapItem", "private", "<QGraphicsPixmapItem>", "public" ] },
+    { symbol: [ "QGraphicsPolygonItem", "private", "<QGraphicsPolygonItem>", "public" ] },
+    { symbol: [ "QGraphicsProxyWidget", "private", "<QGraphicsProxyWidget>", "public" ] },
+    { symbol: [ "QGraphicsRectItem", "private", "<QGraphicsRectItem>", "public" ] },
+    { symbol: [ "QGraphicsRotation", "private", "<QGraphicsRotation>", "public" ] },
+    { symbol: [ "QGraphicsScale", "private", "<QGraphicsScale>", "public" ] },
+    { symbol: [ "QGraphicsScene", "private", "<QGraphicsScene>", "public" ] },
+    { symbol: [ "QGraphicsSceneContextMenuEvent", "private", "<QGraphicsSceneContextMenuEvent>", "public" ] },
+    { symbol: [ "QGraphicsSceneDragDropEvent", "private", "<QGraphicsSceneDragDropEvent>", "public" ] },
+    { symbol: [ "QGraphicsSceneEvent", "private", "<QGraphicsSceneEvent>", "public" ] },
+    { symbol: [ "QGraphicsSceneHelpEvent", "private", "<QGraphicsSceneHelpEvent>", "public" ] },
+    { symbol: [ "QGraphicsSceneHoverEvent", "private", "<QGraphicsSceneHoverEvent>", "public" ] },
+    { symbol: [ "QGraphicsSceneMouseEvent", "private", "<QGraphicsSceneMouseEvent>", "public" ] },
+    { symbol: [ "QGraphicsSceneMoveEvent", "private", "<QGraphicsSceneMoveEvent>", "public" ] },
+    { symbol: [ "QGraphicsSceneResizeEvent", "private", "<QGraphicsSceneResizeEvent>", "public" ] },
+    { symbol: [ "QGraphicsSceneWheelEvent", "private", "<QGraphicsSceneWheelEvent>", "public" ] },
+    { symbol: [ "QGraphicsSimpleTextItem", "private", "<QGraphicsSimpleTextItem>", "public" ] },
+    { symbol: [ "QGraphicsSvgItem", "private", "<QGraphicsSvgItem>", "public" ] },
+    { symbol: [ "QGraphicsTextItem", "private", "<QGraphicsTextItem>", "public" ] },
+    { symbol: [ "QGraphicsTransform", "private", "<QGraphicsTransform>", "public" ] },
+    { symbol: [ "QGraphicsVideoItem", "private", "<QGraphicsVideoItem>", "public" ] },
+    { symbol: [ "QGraphicsView", "private", "<QGraphicsView>", "public" ] },
+    { symbol: [ "QGraphicsWebView", "private", "<QGraphicsWebView>", "public" ] },
+    { symbol: [ "QGraphicsWidget", "private", "<QGraphicsWidget>", "public" ] },
+    { symbol: [ "QGridLayout", "private", "<QGridLayout>", "public" ] },
+    { symbol: [ "QGroupBox", "private", "<QGroupBox>", "public" ] },
+    { symbol: [ "QGuiApplication", "private", "<QGuiApplication>", "public" ] },
+    { symbol: [ "QGyroscope", "private", "<QGyroscope>", "public" ] },
+    { symbol: [ "QGyroscopeFilter", "private", "<QGyroscopeFilter>", "public" ] },
+    { symbol: [ "QGyroscopeReading", "private", "<QGyroscopeReading>", "public" ] },
+    { symbol: [ "QHBoxLayout", "private", "<QHBoxLayout>", "public" ] },
+    { symbol: [ "QHash", "private", "<QHash>", "public" ] },
+    { symbol: [ "QHashData", "private", "<QHashData>", "public" ] },
+    { symbol: [ "QHashDummyValue", "private", "<QHashDummyValue>", "public" ] },
+    { symbol: [ "QHashIterator", "private", "<QHashIterator>", "public" ] },
+    { symbol: [ "QHashNode", "private", "<QHashNode>", "public" ] },
+    { symbol: [ "QHeaderView", "private", "<QHeaderView>", "public" ] },
+    { symbol: [ "QHelpContentItem", "private", "<QHelpContentItem>", "public" ] },
+    { symbol: [ "QHelpContentModel", "private", "<QHelpContentModel>", "public" ] },
+    { symbol: [ "QHelpContentWidget", "private", "<QHelpContentWidget>", "public" ] },
+    { symbol: [ "QHelpEngine", "private", "<QHelpEngine>", "public" ] },
+    { symbol: [ "QHelpEngineCore", "private", "<QHelpEngineCore>", "public" ] },
+    { symbol: [ "QHelpEvent", "private", "<QHelpEvent>", "public" ] },
+    { symbol: [ "QHelpGlobal", "private", "<QHelpGlobal>", "public" ] },
+    { symbol: [ "QHelpIndexModel", "private", "<QHelpIndexModel>", "public" ] },
+    { symbol: [ "QHelpIndexWidget", "private", "<QHelpIndexWidget>", "public" ] },
+    { symbol: [ "QHelpSearchEngine", "private", "<QHelpSearchEngine>", "public" ] },
+    { symbol: [ "QHelpSearchQuery", "private", "<QHelpSearchQuery>", "public" ] },
+    { symbol: [ "QHelpSearchQueryWidget", "private", "<QHelpSearchQueryWidget>", "public" ] },
+    { symbol: [ "QHelpSearchResultWidget", "private", "<QHelpSearchResultWidget>", "public" ] },
+    { symbol: [ "QHideEvent", "private", "<QHideEvent>", "public" ] },
+    { symbol: [ "QHistoryState", "private", "<QHistoryState>", "public" ] },
+    { symbol: [ "QHolsterFilter", "private", "<QHolsterFilter>", "public" ] },
+    { symbol: [ "QHolsterReading", "private", "<QHolsterReading>", "public" ] },
+    { symbol: [ "QHolsterSensor", "private", "<QHolsterSensor>", "public" ] },
+    { symbol: [ "QHostAddress", "private", "<QHostAddress>", "public" ] },
+    { symbol: [ "QHostInfo", "private", "<QHostInfo>", "public" ] },
+    { symbol: [ "QHoverEvent", "private", "<QHoverEvent>", "public" ] },
+    { symbol: [ "QHttpMultiPart", "private", "<QHttpMultiPart>", "public" ] },
+    { symbol: [ "QHttpPart", "private", "<QHttpPart>", "public" ] },
+    { symbol: [ "QIODevice", "private", "<QIODevice>", "public" ] },
+    { symbol: [ "QIPv6Address", "private", "<QIPv6Address>", "public" ] },
+    { symbol: [ "QIRProximityFilter", "private", "<QIRProximityFilter>", "public" ] },
+    { symbol: [ "QIRProximityReading", "private", "<QIRProximityReading>", "public" ] },
+    { symbol: [ "QIRProximitySensor", "private", "<QIRProximitySensor>", "public" ] },
+    { symbol: [ "QIcon", "private", "<QIcon>", "public" ] },
+    { symbol: [ "QIconDragEvent", "private", "<QIconDragEvent>", "public" ] },
+    { symbol: [ "QIconEngine", "private", "<QIconEngine>", "public" ] },
+    { symbol: [ "QIconEnginePlugin", "private", "<QIconEnginePlugin>", "public" ] },
+    { symbol: [ "QIconEngineV2", "private", "<QIconEngineV2>", "public" ] },
+    { symbol: [ "QIdentityProxyModel", "private", "<QIdentityProxyModel>", "public" ] },
+    { symbol: [ "QImage", "private", "<QImage>", "public" ] },
+    { symbol: [ "QImageCleanupFunction", "private", "<QImageCleanupFunction>", "public" ] },
+    { symbol: [ "QImageEncoderControl", "private", "<QImageEncoderControl>", "public" ] },
+    { symbol: [ "QImageEncoderSettings", "private", "<QImageEncoderSettings>", "public" ] },
+    { symbol: [ "QImageIOHandler", "private", "<QImageIOHandler>", "public" ] },
+    { symbol: [ "QImageIOPlugin", "private", "<QImageIOPlugin>", "public" ] },
+    { symbol: [ "QImageReader", "private", "<QImageReader>", "public" ] },
+    { symbol: [ "QImageTextKeyLang", "private", "<QImageTextKeyLang>", "public" ] },
+    { symbol: [ "QImageWriter", "private", "<QImageWriter>", "public" ] },
+    { symbol: [ "QIncompatibleFlag", "private", "<QIncompatibleFlag>", "public" ] },
+    { symbol: [ "QInputDialog", "private", "<QInputDialog>", "public" ] },
+    { symbol: [ "QInputEvent", "private", "<QInputEvent>", "public" ] },
+    { symbol: [ "QInputMethod", "private", "<QInputMethod>", "public" ] },
+    { symbol: [ "QInputMethodEvent", "private", "<QInputMethodEvent>", "public" ] },
+    { symbol: [ "QInputMethodQueryEvent", "private", "<QInputMethodQueryEvent>", "public" ] },
+    { symbol: [ "QIntValidator", "private", "<QIntValidator>", "public" ] },
+    { symbol: [ "QIntegerForSize", "private", "<QIntegerForSize>", "public" ] },
+    { symbol: [ "QInternal", "private", "<QInternal>", "public" ] },
+    { symbol: [ "QItemDelegate", "private", "<QItemDelegate>", "public" ] },
+    { symbol: [ "QItemEditorCreator", "private", "<QItemEditorCreator>", "public" ] },
+    { symbol: [ "QItemEditorCreatorBase", "private", "<QItemEditorCreatorBase>", "public" ] },
+    { symbol: [ "QItemEditorFactory", "private", "<QItemEditorFactory>", "public" ] },
+    { symbol: [ "QItemSelection", "private", "<QItemSelection>", "public" ] },
+    { symbol: [ "QItemSelectionModel", "private", "<QItemSelectionModel>", "public" ] },
+    { symbol: [ "QItemSelectionRange", "private", "<QItemSelectionRange>", "public" ] },
+    { symbol: [ "QJSEngine", "private", "<QJSEngine>", "public" ] },
+    { symbol: [ "QJSValue", "private", "<QJSValue>", "public" ] },
+    { symbol: [ "QJSValueIterator", "private", "<QJSValueIterator>", "public" ] },
+    { symbol: [ "QJSValueList", "private", "<QJSValueList>", "public" ] },
+    { symbol: [ "QJsonArray", "private", "<QJsonArray>", "public" ] },
+    { symbol: [ "QJsonDocument", "private", "<QJsonDocument>", "public" ] },
+    { symbol: [ "QJsonObject", "private", "<QJsonObject>", "public" ] },
+    { symbol: [ "QJsonParseError", "private", "<QJsonParseError>", "public" ] },
+    { symbol: [ "QJsonValue", "private", "<QJsonValue>", "public" ] },
+    { symbol: [ "QJsonValuePtr", "private", "<QJsonValuePtr>", "public" ] },
+    { symbol: [ "QJsonValueRef", "private", "<QJsonValueRef>", "public" ] },
+    { symbol: [ "QJsonValueRefPtr", "private", "<QJsonValueRefPtr>", "public" ] },
+    { symbol: [ "QKeyEvent", "private", "<QKeyEvent>", "public" ] },
+    { symbol: [ "QKeyEventTransition", "private", "<QKeyEventTransition>", "public" ] },
+    { symbol: [ "QKeySequence", "private", "<QKeySequence>", "public" ] },
+    { symbol: [ "QKeySequenceEdit", "private", "<QKeySequenceEdit>", "public" ] },
+    { symbol: [ "QLCDNumber", "private", "<QLCDNumber>", "public" ] },
+    { symbol: [ "QLabel", "private", "<QLabel>", "public" ] },
+    { symbol: [ "QLatin1Char", "private", "<QLatin1Char>", "public" ] },
+    { symbol: [ "QLatin1Literal", "private", "<QLatin1Literal>", "public" ] },
+    { symbol: [ "QLatin1String", "private", "<QLatin1String>", "public" ] },
+    { symbol: [ "QLayout", "private", "<QLayout>", "public" ] },
+    { symbol: [ "QLayoutItem", "private", "<QLayoutItem>", "public" ] },
+    { symbol: [ "QLibrary", "private", "<QLibrary>", "public" ] },
+    { symbol: [ "QLibraryInfo", "private", "<QLibraryInfo>", "public" ] },
+    { symbol: [ "QLightFilter", "private", "<QLightFilter>", "public" ] },
+    { symbol: [ "QLightReading", "private", "<QLightReading>", "public" ] },
+    { symbol: [ "QLightSensor", "private", "<QLightSensor>", "public" ] },
+    { symbol: [ "QLine", "private", "<QLine>", "public" ] },
+    { symbol: [ "QLineEdit", "private", "<QLineEdit>", "public" ] },
+    { symbol: [ "QLineF", "private", "<QLineF>", "public" ] },
+    { symbol: [ "QLinearGradient", "private", "<QLinearGradient>", "public" ] },
+    { symbol: [ "QLinkedList", "private", "<QLinkedList>", "public" ] },
+    { symbol: [ "QLinkedListData", "private", "<QLinkedListData>", "public" ] },
+    { symbol: [ "QLinkedListIterator", "private", "<QLinkedListIterator>", "public" ] },
+    { symbol: [ "QLinkedListNode", "private", "<QLinkedListNode>", "public" ] },
+    { symbol: [ "QList", "private", "<QList>", "public" ] },
+    { symbol: [ "QListData", "private", "<QListData>", "public" ] },
+    { symbol: [ "QListIterator", "private", "<QListIterator>", "public" ] },
+    { symbol: [ "QListSpecialMethods", "private", "<QListSpecialMethods>", "public" ] },
+    { symbol: [ "QListView", "private", "<QListView>", "public" ] },
+    { symbol: [ "QListWidget", "private", "<QListWidget>", "public" ] },
+    { symbol: [ "QListWidgetItem", "private", "<QListWidgetItem>", "public" ] },
+    { symbol: [ "QLocalServer", "private", "<QLocalServer>", "public" ] },
+    { symbol: [ "QLocalSocket", "private", "<QLocalSocket>", "public" ] },
+    { symbol: [ "QLocale", "private", "<QLocale>", "public" ] },
+    { symbol: [ "QLocation", "private", "<QLocation>", "public" ] },
+    { symbol: [ "QLockFile", "private", "<QLockFile>", "public" ] },
+    { symbol: [ "QLockFile", "private", "<QLockFile>", "public" ] },
+    { symbol: [ "QLoggingCategory", "private", "<QLoggingCategory>", "public" ] },
+    { symbol: [ "QLowEnergyCharacteristic", "private", "<QLowEnergyCharacteristic>", "public" ] },
+    { symbol: [ "QLowEnergyController", "private", "<QLowEnergyController>", "public" ] },
+    { symbol: [ "QLowEnergyDescriptor", "private", "<QLowEnergyDescriptor>", "public" ] },
+    { symbol: [ "QLowEnergyHandle", "private", "<QLowEnergyHandle>", "public" ] },
+    { symbol: [ "QLowEnergyService", "private", "<QLowEnergyService>", "public" ] },
+    { symbol: [ "QMacCocoaViewContainer", "private", "<QMacCocoaViewContainer>", "public" ] },
+    { symbol: [ "QMacNativeWidget", "private", "<QMacNativeWidget>", "public" ] },
+    { symbol: [ "QMagnetometer", "private", "<QMagnetometer>", "public" ] },
+    { symbol: [ "QMagnetometerFilter", "private", "<QMagnetometerFilter>", "public" ] },
+    { symbol: [ "QMagnetometerReading", "private", "<QMagnetometerReading>", "public" ] },
+    { symbol: [ "QMainWindow", "private", "<QMainWindow>", "public" ] },
+    { symbol: [ "QMap", "private", "<QMap>", "public" ] },
+    { symbol: [ "QMapData", "private", "<QMapData>", "public" ] },
+    { symbol: [ "QMapDataBase", "private", "<QMapDataBase>", "public" ] },
+    { symbol: [ "QMapIterator", "private", "<QMapIterator>", "public" ] },
+    { symbol: [ "QMapNode", "private", "<QMapNode>", "public" ] },
+    { symbol: [ "QMapNodeBase", "private", "<QMapNodeBase>", "public" ] },
+    { symbol: [ "QMargins", "private", "<QMargins>", "public" ] },
+    { symbol: [ "QMarginsF", "private", "<QMarginsF>", "public" ] },
+    { symbol: [ "QMaskGenerator", "private", "<QMaskGenerator>", "public" ] },
+    { symbol: [ "QMatrix", "private", "<QMatrix>", "public" ] },
+    { symbol: [ "QMatrix2x2", "private", "<QMatrix2x2>", "public" ] },
+    { symbol: [ "QMatrix2x3", "private", "<QMatrix2x3>", "public" ] },
+    { symbol: [ "QMatrix2x4", "private", "<QMatrix2x4>", "public" ] },
+    { symbol: [ "QMatrix3x2", "private", "<QMatrix3x2>", "public" ] },
+    { symbol: [ "QMatrix3x3", "private", "<QMatrix3x3>", "public" ] },
+    { symbol: [ "QMatrix3x4", "private", "<QMatrix3x4>", "public" ] },
+    { symbol: [ "QMatrix4x2", "private", "<QMatrix4x2>", "public" ] },
+    { symbol: [ "QMatrix4x3", "private", "<QMatrix4x3>", "public" ] },
+    { symbol: [ "QMatrix4x4", "private", "<QMatrix4x4>", "public" ] },
+    { symbol: [ "QMdiArea", "private", "<QMdiArea>", "public" ] },
+    { symbol: [ "QMdiSubWindow", "private", "<QMdiSubWindow>", "public" ] },
+    { symbol: [ "QMediaAudioProbeControl", "private", "<QMediaAudioProbeControl>", "public" ] },
+    { symbol: [ "QMediaAvailabilityControl", "private", "<QMediaAvailabilityControl>", "public" ] },
+    { symbol: [ "QMediaBindableInterface", "private", "<QMediaBindableInterface>", "public" ] },
+    { symbol: [ "QMediaContainerControl", "private", "<QMediaContainerControl>", "public" ] },
+    { symbol: [ "QMediaContent", "private", "<QMediaContent>", "public" ] },
+    { symbol: [ "QMediaControl", "private", "<QMediaControl>", "public" ] },
+    { symbol: [ "QMediaGaplessPlaybackControl", "private", "<QMediaGaplessPlaybackControl>", "public" ] },
+    { symbol: [ "QMediaMetaData", "private", "<QMediaMetaData>", "public" ] },
+    { symbol: [ "QMediaNetworkAccessControl", "private", "<QMediaNetworkAccessControl>", "public" ] },
+    { symbol: [ "QMediaObject", "private", "<QMediaObject>", "public" ] },
+    { symbol: [ "QMediaPlayer", "private", "<QMediaPlayer>", "public" ] },
+    { symbol: [ "QMediaPlayerControl", "private", "<QMediaPlayerControl>", "public" ] },
+    { symbol: [ "QMediaPlaylist", "private", "<QMediaPlaylist>", "public" ] },
+    { symbol: [ "QMediaRecorder", "private", "<QMediaRecorder>", "public" ] },
+    { symbol: [ "QMediaRecorderControl", "private", "<QMediaRecorderControl>", "public" ] },
+    { symbol: [ "QMediaResource", "private", "<QMediaResource>", "public" ] },
+    { symbol: [ "QMediaResourceList", "private", "<QMediaResourceList>", "public" ] },
+    { symbol: [ "QMediaService", "private", "<QMediaService>", "public" ] },
+    { symbol: [ "QMediaServiceCameraInfoInterface", "private", "<QMediaServiceCameraInfoInterface>", "public" ] },
+    { symbol: [ "QMediaServiceDefaultDeviceInterface", "private", "<QMediaServiceDefaultDeviceInterface>", "public" ] },
+    { symbol: [ "QMediaServiceFeaturesInterface", "private", "<QMediaServiceFeaturesInterface>", "public" ] },
+    { symbol: [ "QMediaServiceProviderFactoryInterface", "private", "<QMediaServiceProviderFactoryInterface>", "public" ] },
+    { symbol: [ "QMediaServiceProviderHint", "private", "<QMediaServiceProviderHint>", "public" ] },
+    { symbol: [ "QMediaServiceProviderPlugin", "private", "<QMediaServiceProviderPlugin>", "public" ] },
+    { symbol: [ "QMediaServiceSupportedDevicesInterface", "private", "<QMediaServiceSupportedDevicesInterface>", "public" ] },
+    { symbol: [ "QMediaServiceSupportedFormatsInterface", "private", "<QMediaServiceSupportedFormatsInterface>", "public" ] },
+    { symbol: [ "QMediaStreamsControl", "private", "<QMediaStreamsControl>", "public" ] },
+    { symbol: [ "QMediaTimeInterval", "private", "<QMediaTimeInterval>", "public" ] },
+    { symbol: [ "QMediaTimeRange", "private", "<QMediaTimeRange>", "public" ] },
+    { symbol: [ "QMediaVideoProbeControl", "private", "<QMediaVideoProbeControl>", "public" ] },
+    { symbol: [ "QMenu", "private", "<QMenu>", "public" ] },
+    { symbol: [ "QMenuBar", "private", "<QMenuBar>", "public" ] },
+    { symbol: [ "QMessageAuthenticationCode", "private", "<QMessageAuthenticationCode>", "public" ] },
+    { symbol: [ "QMessageBox", "private", "<QMessageBox>", "public" ] },
+    { symbol: [ "QMessageLogContext", "private", "<QMessageLogContext>", "public" ] },
+    { symbol: [ "QMessageLogger", "private", "<QMessageLogger>", "public" ] },
+    { symbol: [ "QMetaClassInfo", "private", "<QMetaClassInfo>", "public" ] },
+    { symbol: [ "QMetaDataReaderControl", "private", "<QMetaDataReaderControl>", "public" ] },
+    { symbol: [ "QMetaDataWriterControl", "private", "<QMetaDataWriterControl>", "public" ] },
+    { symbol: [ "QMetaEnum", "private", "<QMetaEnum>", "public" ] },
+    { symbol: [ "QMetaMethod", "private", "<QMetaMethod>", "public" ] },
+    { symbol: [ "QMetaObject", "private", "<QMetaObject>", "public" ] },
+    { symbol: [ "QMetaProperty", "private", "<QMetaProperty>", "public" ] },
+    { symbol: [ "QMetaType", "private", "<QMetaType>", "public" ] },
+    { symbol: [ "QMetaTypeId", "private", "<QMetaTypeId>", "public" ] },
+    { symbol: [ "QMetaTypeId2", "private", "<QMetaTypeId2>", "public" ] },
+    { symbol: [ "QMetaTypeIdQObject", "private", "<QMetaTypeIdQObject>", "public" ] },
+    { symbol: [ "QMimeData", "private", "<QMimeData>", "public" ] },
+    { symbol: [ "QMimeDatabase", "private", "<QMimeDatabase>", "public" ] },
+    { symbol: [ "QMimeType", "private", "<QMimeType>", "public" ] },
+    { symbol: [ "QModelIndex", "private", "<QModelIndex>", "public" ] },
+    { symbol: [ "QModelIndexList", "private", "<QModelIndexList>", "public" ] },
+    { symbol: [ "QMouseEvent", "private", "<QMouseEvent>", "public" ] },
+    { symbol: [ "QMouseEventTransition", "private", "<QMouseEventTransition>", "public" ] },
+    { symbol: [ "QMoveEvent", "private", "<QMoveEvent>", "public" ] },
+    { symbol: [ "QMovie", "private", "<QMovie>", "public" ] },
+    { symbol: [ "QMultiHash", "private", "<QMultiHash>", "public" ] },
+    { symbol: [ "QMultiMap", "private", "<QMultiMap>", "public" ] },
+    { symbol: [ "QMultimedia", "private", "<QMultimedia>", "public" ] },
+    { symbol: [ "QMutableByteArrayListIterator", "private", "<QMutableByteArrayListIterator>", "public" ] },
+    { symbol: [ "QMutableFutureIterator", "private", "<QMutableFutureIterator>", "public" ] },
+    { symbol: [ "QMutableHashIterator", "private", "<QMutableHashIterator>", "public" ] },
+    { symbol: [ "QMutableLinkedListIterator", "private", "<QMutableLinkedListIterator>", "public" ] },
+    { symbol: [ "QMutableListIterator", "private", "<QMutableListIterator>", "public" ] },
+    { symbol: [ "QMutableMapIterator", "private", "<QMutableMapIterator>", "public" ] },
+    { symbol: [ "QMutableSetIterator", "private", "<QMutableSetIterator>", "public" ] },
+    { symbol: [ "QMutableStringListIterator", "private", "<QMutableStringListIterator>", "public" ] },
+    { symbol: [ "QMutableVectorIterator", "private", "<QMutableVectorIterator>", "public" ] },
+    { symbol: [ "QMutex", "private", "<QMutex>", "public" ] },
+    { symbol: [ "QMutexLocker", "private", "<QMutexLocker>", "public" ] },
+    { symbol: [ "QNativeGestureEvent", "private", "<QNativeGestureEvent>", "public" ] },
+    { symbol: [ "QNdefFilter", "private", "<QNdefFilter>", "public" ] },
+    { symbol: [ "QNdefMessage", "private", "<QNdefMessage>", "public" ] },
+    { symbol: [ "QNdefNfcIconRecord", "private", "<QNdefNfcIconRecord>", "public" ] },
+    { symbol: [ "QNdefNfcSmartPosterRecord", "private", "<QNdefNfcSmartPosterRecord>", "public" ] },
+    { symbol: [ "QNdefNfcTextRecord", "private", "<QNdefNfcTextRecord>", "public" ] },
+    { symbol: [ "QNdefNfcUriRecord", "private", "<QNdefNfcUriRecord>", "public" ] },
+    { symbol: [ "QNdefRecord", "private", "<QNdefRecord>", "public" ] },
+    { symbol: [ "QNearFieldManager", "private", "<QNearFieldManager>", "public" ] },
+    { symbol: [ "QNearFieldShareManager", "private", "<QNearFieldShareManager>", "public" ] },
+    { symbol: [ "QNearFieldShareTarget", "private", "<QNearFieldShareTarget>", "public" ] },
+    { symbol: [ "QNearFieldTarget", "private", "<QNearFieldTarget>", "public" ] },
+    { symbol: [ "QNetworkAccessManager", "private", "<QNetworkAccessManager>", "public" ] },
+    { symbol: [ "QNetworkAddressEntry", "private", "<QNetworkAddressEntry>", "public" ] },
+    { symbol: [ "QNetworkCacheMetaData", "private", "<QNetworkCacheMetaData>", "public" ] },
+    { symbol: [ "QNetworkConfiguration", "private", "<QNetworkConfiguration>", "public" ] },
+    { symbol: [ "QNetworkConfigurationManager", "private", "<QNetworkConfigurationManager>", "public" ] },
+    { symbol: [ "QNetworkCookie", "private", "<QNetworkCookie>", "public" ] },
+    { symbol: [ "QNetworkCookieJar", "private", "<QNetworkCookieJar>", "public" ] },
+    { symbol: [ "QNetworkDiskCache", "private", "<QNetworkDiskCache>", "public" ] },
+    { symbol: [ "QNetworkInterface", "private", "<QNetworkInterface>", "public" ] },
+    { symbol: [ "QNetworkProxy", "private", "<QNetworkProxy>", "public" ] },
+    { symbol: [ "QNetworkProxyFactory", "private", "<QNetworkProxyFactory>", "public" ] },
+    { symbol: [ "QNetworkProxyQuery", "private", "<QNetworkProxyQuery>", "public" ] },
+    { symbol: [ "QNetworkReply", "private", "<QNetworkReply>", "public" ] },
+    { symbol: [ "QNetworkRequest", "private", "<QNetworkRequest>", "public" ] },
+    { symbol: [ "QNetworkSession", "private", "<QNetworkSession>", "public" ] },
+    { symbol: [ "QNmeaPositionInfoSource", "private", "<QNmeaPositionInfoSource>", "public" ] },
+    { symbol: [ "QNoDebug", "private", "<QNoDebug>", "public" ] },
+    { symbol: [ "QObject", "private", "<QObject>", "public" ] },
+    { symbol: [ "QObjectCleanupHandler", "private", "<QObjectCleanupHandler>", "public" ] },
+    { symbol: [ "QObjectData", "private", "<QObjectData>", "public" ] },
+    { symbol: [ "QObjectList", "private", "<QObjectList>", "public" ] },
+    { symbol: [ "QObjectUserData", "private", "<QObjectUserData>", "public" ] },
+    { symbol: [ "QOffscreenSurface", "private", "<QOffscreenSurface>", "public" ] },
+    { symbol: [ "QOpenGLBuffer", "private", "<QOpenGLBuffer>", "public" ] },
+    { symbol: [ "QOpenGLContext", "private", "<QOpenGLContext>", "public" ] },
+    { symbol: [ "QOpenGLContextGroup", "private", "<QOpenGLContextGroup>", "public" ] },
+    { symbol: [ "QOpenGLDebugLogger", "private", "<QOpenGLDebugLogger>", "public" ] },
+    { symbol: [ "QOpenGLDebugMessage", "private", "<QOpenGLDebugMessage>", "public" ] },
+    { symbol: [ "QOpenGLExtensions", "private", "<QOpenGLExtensions>", "public" ] },
+    { symbol: [ "QOpenGLFramebufferObject", "private", "<QOpenGLFramebufferObject>", "public" ] },
+    { symbol: [ "QOpenGLFramebufferObjectFormat", "private", "<QOpenGLFramebufferObjectFormat>", "public" ] },
+    { symbol: [ "QOpenGLFunctions", "private", "<QOpenGLFunctions>", "public" ] },
+    { symbol: [ "QOpenGLFunctionsPrivate", "private", "<QOpenGLFunctionsPrivate>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_1_0", "private", "<QOpenGLFunctions_1_0>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_1_1", "private", "<QOpenGLFunctions_1_1>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_1_2", "private", "<QOpenGLFunctions_1_2>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_1_3", "private", "<QOpenGLFunctions_1_3>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_1_4", "private", "<QOpenGLFunctions_1_4>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_1_5", "private", "<QOpenGLFunctions_1_5>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_2_0", "private", "<QOpenGLFunctions_2_0>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_2_1", "private", "<QOpenGLFunctions_2_1>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_3_0", "private", "<QOpenGLFunctions_3_0>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_3_1", "private", "<QOpenGLFunctions_3_1>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_3_2_Compatibility", "private", "<QOpenGLFunctions_3_2_Compatibility>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_3_2_Core", "private", "<QOpenGLFunctions_3_2_Core>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_3_3_Compatibility", "private", "<QOpenGLFunctions_3_3_Compatibility>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_3_3_Core", "private", "<QOpenGLFunctions_3_3_Core>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_4_0_Compatibility", "private", "<QOpenGLFunctions_4_0_Compatibility>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_4_0_Core", "private", "<QOpenGLFunctions_4_0_Core>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_4_1_Compatibility", "private", "<QOpenGLFunctions_4_1_Compatibility>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_4_1_Core", "private", "<QOpenGLFunctions_4_1_Core>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_4_2_Compatibility", "private", "<QOpenGLFunctions_4_2_Compatibility>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_4_2_Core", "private", "<QOpenGLFunctions_4_2_Core>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_4_3_Compatibility", "private", "<QOpenGLFunctions_4_3_Compatibility>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_4_3_Core", "private", "<QOpenGLFunctions_4_3_Core>", "public" ] },
+    { symbol: [ "QOpenGLFunctions_ES2", "private", "<QOpenGLFunctions_ES2>", "public" ] },
+    { symbol: [ "QOpenGLPaintDevice", "private", "<QOpenGLPaintDevice>", "public" ] },
+    { symbol: [ "QOpenGLPixelTransferOptions", "private", "<QOpenGLPixelTransferOptions>", "public" ] },
+    { symbol: [ "QOpenGLShader", "private", "<QOpenGLShader>", "public" ] },
+    { symbol: [ "QOpenGLShaderProgram", "private", "<QOpenGLShaderProgram>", "public" ] },
+    { symbol: [ "QOpenGLTexture", "private", "<QOpenGLTexture>", "public" ] },
+    { symbol: [ "QOpenGLTimeMonitor", "private", "<QOpenGLTimeMonitor>", "public" ] },
+    { symbol: [ "QOpenGLTimerQuery", "private", "<QOpenGLTimerQuery>", "public" ] },
+    { symbol: [ "QOpenGLVersionFunctions", "private", "<QOpenGLVersionFunctions>", "public" ] },
+    { symbol: [ "QOpenGLVersionProfile", "private", "<QOpenGLVersionProfile>", "public" ] },
+    { symbol: [ "QOpenGLVertexArrayObject", "private", "<QOpenGLVertexArrayObject>", "public" ] },
+    { symbol: [ "QOpenGLWidget", "private", "<QOpenGLWidget>", "public" ] },
+    { symbol: [ "QOpenGLWindow", "private", "<QOpenGLWindow>", "public" ] },
+    { symbol: [ "QOrientationFilter", "private", "<QOrientationFilter>", "public" ] },
+    { symbol: [ "QOrientationReading", "private", "<QOrientationReading>", "public" ] },
+    { symbol: [ "QOrientationSensor", "private", "<QOrientationSensor>", "public" ] },
+    { symbol: [ "QPageLayout", "private", "<QPageLayout>", "public" ] },
+    { symbol: [ "QPageSetupDialog", "private", "<QPageSetupDialog>", "public" ] },
+    { symbol: [ "QPageSize", "private", "<QPageSize>", "public" ] },
+    { symbol: [ "QPagedPaintDevice", "private", "<QPagedPaintDevice>", "public" ] },
+    { symbol: [ "QPaintDevice", "private", "<QPaintDevice>", "public" ] },
+    { symbol: [ "QPaintDeviceWindow", "private", "<QPaintDeviceWindow>", "public" ] },
+    { symbol: [ "QPaintEngine", "private", "<QPaintEngine>", "public" ] },
+    { symbol: [ "QPaintEngineState", "private", "<QPaintEngineState>", "public" ] },
+    { symbol: [ "QPaintEvent", "private", "<QPaintEvent>", "public" ] },
+    { symbol: [ "QPainter", "private", "<QPainter>", "public" ] },
+    { symbol: [ "QPainterPath", "private", "<QPainterPath>", "public" ] },
+    { symbol: [ "QPainterPathStroker", "private", "<QPainterPathStroker>", "public" ] },
+    { symbol: [ "QPair", "private", "<QPair>", "public" ] },
+    { symbol: [ "QPalette", "private", "<QPalette>", "public" ] },
+    { symbol: [ "QPanGesture", "private", "<QPanGesture>", "public" ] },
+    { symbol: [ "QParallelAnimationGroup", "private", "<QParallelAnimationGroup>", "public" ] },
+    { symbol: [ "QPauseAnimation", "private", "<QPauseAnimation>", "public" ] },
+    { symbol: [ "QPdfWriter", "private", "<QPdfWriter>", "public" ] },
+    { symbol: [ "QPen", "private", "<QPen>", "public" ] },
+    { symbol: [ "QPersistentModelIndex", "private", "<QPersistentModelIndex>", "public" ] },
+    { symbol: [ "QPicture", "private", "<QPicture>", "public" ] },
+    { symbol: [ "QPictureFormatPlugin", "private", "<QPictureFormatPlugin>", "public" ] },
+    { symbol: [ "QPictureIO", "private", "<QPictureIO>", "public" ] },
+    { symbol: [ "QPinchGesture", "private", "<QPinchGesture>", "public" ] },
+    { symbol: [ "QPixelFormat", "private", "<QPixelFormat>", "public" ] },
+    { symbol: [ "QPixmap", "private", "<QPixmap>", "public" ] },
+    { symbol: [ "QPixmapCache", "private", "<QPixmapCache>", "public" ] },
+    { symbol: [ "QPlace", "private", "<QPlace>", "public" ] },
+    { symbol: [ "QPlaceAttribute", "private", "<QPlaceAttribute>", "public" ] },
+    { symbol: [ "QPlaceCategory", "private", "<QPlaceCategory>", "public" ] },
+    { symbol: [ "QPlaceContactDetail", "private", "<QPlaceContactDetail>", "public" ] },
+    { symbol: [ "QPlaceContent", "private", "<QPlaceContent>", "public" ] },
+    { symbol: [ "QPlaceContentReply", "private", "<QPlaceContentReply>", "public" ] },
+    { symbol: [ "QPlaceContentRequest", "private", "<QPlaceContentRequest>", "public" ] },
+    { symbol: [ "QPlaceDetailsReply", "private", "<QPlaceDetailsReply>", "public" ] },
+    { symbol: [ "QPlaceEditorial", "private", "<QPlaceEditorial>", "public" ] },
+    { symbol: [ "QPlaceIcon", "private", "<QPlaceIcon>", "public" ] },
+    { symbol: [ "QPlaceIdReply", "private", "<QPlaceIdReply>", "public" ] },
+    { symbol: [ "QPlaceImage", "private", "<QPlaceImage>", "public" ] },
+    { symbol: [ "QPlaceManager", "private", "<QPlaceManager>", "public" ] },
+    { symbol: [ "QPlaceManagerEngine", "private", "<QPlaceManagerEngine>", "public" ] },
+    { symbol: [ "QPlaceMatchReply", "private", "<QPlaceMatchReply>", "public" ] },
+    { symbol: [ "QPlaceMatchRequest", "private", "<QPlaceMatchRequest>", "public" ] },
+    { symbol: [ "QPlaceProposedSearchResult", "private", "<QPlaceProposedSearchResult>", "public" ] },
+    { symbol: [ "QPlaceRatings", "private", "<QPlaceRatings>", "public" ] },
+    { symbol: [ "QPlaceReply", "private", "<QPlaceReply>", "public" ] },
+    { symbol: [ "QPlaceResult", "private", "<QPlaceResult>", "public" ] },
+    { symbol: [ "QPlaceReview", "private", "<QPlaceReview>", "public" ] },
+    { symbol: [ "QPlaceSearchReply", "private", "<QPlaceSearchReply>", "public" ] },
+    { symbol: [ "QPlaceSearchRequest", "private", "<QPlaceSearchRequest>", "public" ] },
+    { symbol: [ "QPlaceSearchResult", "private", "<QPlaceSearchResult>", "public" ] },
+    { symbol: [ "QPlaceSearchSuggestionReply", "private", "<QPlaceSearchSuggestionReply>", "public" ] },
+    { symbol: [ "QPlaceSupplier", "private", "<QPlaceSupplier>", "public" ] },
+    { symbol: [ "QPlaceUser", "private", "<QPlaceUser>", "public" ] },
+    { symbol: [ "QPlainTextDocumentLayout", "private", "<QPlainTextDocumentLayout>", "public" ] },
+    { symbol: [ "QPlainTextEdit", "private", "<QPlainTextEdit>", "public" ] },
+    { symbol: [ "QPluginLoader", "private", "<QPluginLoader>", "public" ] },
+    { symbol: [ "QPoint", "private", "<QPoint>", "public" ] },
+    { symbol: [ "QPointF", "private", "<QPointF>", "public" ] },
+    { symbol: [ "QPointer", "private", "<QPointer>", "public" ] },
+    { symbol: [ "QPolygon", "private", "<QPolygon>", "public" ] },
+    { symbol: [ "QPolygonF", "private", "<QPolygonF>", "public" ] },
+    { symbol: [ "QPressureFilter", "private", "<QPressureFilter>", "public" ] },
+    { symbol: [ "QPressureReading", "private", "<QPressureReading>", "public" ] },
+    { symbol: [ "QPressureSensor", "private", "<QPressureSensor>", "public" ] },
+    { symbol: [ "QPrintDialog", "private", "<QPrintDialog>", "public" ] },
+    { symbol: [ "QPrintEngine", "private", "<QPrintEngine>", "public" ] },
+    { symbol: [ "QPrintPreviewDialog", "private", "<QPrintPreviewDialog>", "public" ] },
+    { symbol: [ "QPrintPreviewWidget", "private", "<QPrintPreviewWidget>", "public" ] },
+    { symbol: [ "QPrinter", "private", "<QPrinter>", "public" ] },
+    { symbol: [ "QPrinterInfo", "private", "<QPrinterInfo>", "public" ] },
+    { symbol: [ "QProcess", "private", "<QProcess>", "public" ] },
+    { symbol: [ "QProcessEnvironment", "private", "<QProcessEnvironment>", "public" ] },
+    { symbol: [ "QProgressBar", "private", "<QProgressBar>", "public" ] },
+    { symbol: [ "QProgressDialog", "private", "<QProgressDialog>", "public" ] },
+    { symbol: [ "QPropertyAnimation", "private", "<QPropertyAnimation>", "public" ] },
+    { symbol: [ "QProximityFilter", "private", "<QProximityFilter>", "public" ] },
+    { symbol: [ "QProximityReading", "private", "<QProximityReading>", "public" ] },
+    { symbol: [ "QProximitySensor", "private", "<QProximitySensor>", "public" ] },
+    { symbol: [ "QProxyStyle", "private", "<QProxyStyle>", "public" ] },
+    { symbol: [ "QPushButton", "private", "<QPushButton>", "public" ] },
+    { symbol: [ "QQmlAbstractUrlInterceptor", "private", "<QQmlAbstractUrlInterceptor>", "public" ] },
+    { symbol: [ "QQmlApplicationEngine", "private", "<QQmlApplicationEngine>", "public" ] },
+    { symbol: [ "QQmlAttachedPropertiesFunc", "private", "<QQmlAttachedPropertiesFunc>", "public" ] },
+    { symbol: [ "QQmlComponent", "private", "<QQmlComponent>", "public" ] },
+    { symbol: [ "QQmlContext", "private", "<QQmlContext>", "public" ] },
+    { symbol: [ "QQmlDebuggingEnabler", "private", "<QQmlDebuggingEnabler>", "public" ] },
+    { symbol: [ "QQmlEngine", "private", "<QQmlEngine>", "public" ] },
+    { symbol: [ "QQmlError", "private", "<QQmlError>", "public" ] },
+    { symbol: [ "QQmlExpression", "private", "<QQmlExpression>", "public" ] },
+    { symbol: [ "QQmlExtensionInterface", "private", "<QQmlExtensionInterface>", "public" ] },
+    { symbol: [ "QQmlExtensionPlugin", "private", "<QQmlExtensionPlugin>", "public" ] },
+    { symbol: [ "QQmlFile", "private", "<QQmlFile>", "public" ] },
+    { symbol: [ "QQmlFileSelector", "private", "<QQmlFileSelector>", "public" ] },
+    { symbol: [ "QQmlImageProviderBase", "private", "<QQmlImageProviderBase>", "public" ] },
+    { symbol: [ "QQmlIncubationController", "private", "<QQmlIncubationController>", "public" ] },
+    { symbol: [ "QQmlIncubator", "private", "<QQmlIncubator>", "public" ] },
+    { symbol: [ "QQmlInfo", "private", "<QQmlInfo>", "public" ] },
+    { symbol: [ "QQmlListProperty", "private", "<QQmlListProperty>", "public" ] },
+    { symbol: [ "QQmlListReference", "private", "<QQmlListReference>", "public" ] },
+    { symbol: [ "QQmlNdefRecord", "private", "<QQmlNdefRecord>", "public" ] },
+    { symbol: [ "QQmlNetworkAccessManagerFactory", "private", "<QQmlNetworkAccessManagerFactory>", "public" ] },
+    { symbol: [ "QQmlParserStatus", "private", "<QQmlParserStatus>", "public" ] },
+    { symbol: [ "QQmlProperties", "private", "<QQmlProperties>", "public" ] },
+    { symbol: [ "QQmlProperty", "private", "<QQmlProperty>", "public" ] },
+    { symbol: [ "QQmlPropertyMap", "private", "<QQmlPropertyMap>", "public" ] },
+    { symbol: [ "QQmlPropertyValueSource", "private", "<QQmlPropertyValueSource>", "public" ] },
+    { symbol: [ "QQmlScriptString", "private", "<QQmlScriptString>", "public" ] },
+    { symbol: [ "QQmlTypeInfo", "private", "<QQmlTypeInfo>", "public" ] },
+    { symbol: [ "QQmlTypesExtensionInterface", "private", "<QQmlTypesExtensionInterface>", "public" ] },
+    { symbol: [ "QQmlWebChannel", "private", "<QQmlWebChannel>", "public" ] },
+    { symbol: [ "QQuaternion", "private", "<QQuaternion>", "public" ] },
+    { symbol: [ "QQueue", "private", "<QQueue>", "public" ] },
+    { symbol: [ "QQuickFramebufferObject", "private", "<QQuickFramebufferObject>", "public" ] },
+    { symbol: [ "QQuickImageProvider", "private", "<QQuickImageProvider>", "public" ] },
+    { symbol: [ "QQuickItem", "private", "<QQuickItem>", "public" ] },
+    { symbol: [ "QQuickItemGrabResult", "private", "<QQuickItemGrabResult>", "public" ] },
+    { symbol: [ "QQuickPaintedItem", "private", "<QQuickPaintedItem>", "public" ] },
+    { symbol: [ "QQuickRenderControl", "private", "<QQuickRenderControl>", "public" ] },
+    { symbol: [ "QQuickTextDocument", "private", "<QQuickTextDocument>", "public" ] },
+    { symbol: [ "QQuickTextureFactory", "private", "<QQuickTextureFactory>", "public" ] },
+    { symbol: [ "QQuickTransform", "private", "<QQuickTransform>", "public" ] },
+    { symbol: [ "QQuickView", "private", "<QQuickView>", "public" ] },
+    { symbol: [ "QQuickWidget", "private", "<QQuickWidget>", "public" ] },
+    { symbol: [ "QQuickWindow", "private", "<QQuickWindow>", "public" ] },
+    { symbol: [ "QRadialGradient", "private", "<QRadialGradient>", "public" ] },
+    { symbol: [ "QRadioButton", "private", "<QRadioButton>", "public" ] },
+    { symbol: [ "QRadioData", "private", "<QRadioData>", "public" ] },
+    { symbol: [ "QRadioDataControl", "private", "<QRadioDataControl>", "public" ] },
+    { symbol: [ "QRadioTuner", "private", "<QRadioTuner>", "public" ] },
+    { symbol: [ "QRadioTunerControl", "private", "<QRadioTunerControl>", "public" ] },
+    { symbol: [ "QRasterWindow", "private", "<QRasterWindow>", "public" ] },
+    { symbol: [ "QRawFont", "private", "<QRawFont>", "public" ] },
+    { symbol: [ "QReadLocker", "private", "<QReadLocker>", "public" ] },
+    { symbol: [ "QReadWriteLock", "private", "<QReadWriteLock>", "public" ] },
+    { symbol: [ "QRect", "private", "<QRect>", "public" ] },
+    { symbol: [ "QRectF", "private", "<QRectF>", "public" ] },
+    { symbol: [ "QRegExp", "private", "<QRegExp>", "public" ] },
+    { symbol: [ "QRegExpValidator", "private", "<QRegExpValidator>", "public" ] },
+    { symbol: [ "QRegion", "private", "<QRegion>", "public" ] },
+    { symbol: [ "QRegularExpression", "private", "<QRegularExpression>", "public" ] },
+    { symbol: [ "QRegularExpressionMatch", "private", "<QRegularExpressionMatch>", "public" ] },
+    { symbol: [ "QRegularExpressionMatchIterator", "private", "<QRegularExpressionMatchIterator>", "public" ] },
+    { symbol: [ "QRegularExpressionValidator", "private", "<QRegularExpressionValidator>", "public" ] },
+    { symbol: [ "QResizeEvent", "private", "<QResizeEvent>", "public" ] },
+    { symbol: [ "QResource", "private", "<QResource>", "public" ] },
+    { symbol: [ "QReturnArgument", "private", "<QReturnArgument>", "public" ] },
+    { symbol: [ "QRgb", "private", "<QRgb>", "public" ] },
+    { symbol: [ "QRotationFilter", "private", "<QRotationFilter>", "public" ] },
+    { symbol: [ "QRotationReading", "private", "<QRotationReading>", "public" ] },
+    { symbol: [ "QRotationSensor", "private", "<QRotationSensor>", "public" ] },
+    { symbol: [ "QRubberBand", "private", "<QRubberBand>", "public" ] },
+    { symbol: [ "QRunnable", "private", "<QRunnable>", "public" ] },
+    { symbol: [ "QSGAbstractRenderer", "private", "<QSGAbstractRenderer>", "public" ] },
+    { symbol: [ "QSGBasicGeometryNode", "private", "<QSGBasicGeometryNode>", "public" ] },
+    { symbol: [ "QSGClipNode", "private", "<QSGClipNode>", "public" ] },
+    { symbol: [ "QSGDynamicTexture", "private", "<QSGDynamicTexture>", "public" ] },
+    { symbol: [ "QSGEngine", "private", "<QSGEngine>", "public" ] },
+    { symbol: [ "QSGFlatColorMaterial", "private", "<QSGFlatColorMaterial>", "public" ] },
+    { symbol: [ "QSGGeometry", "private", "<QSGGeometry>", "public" ] },
+    { symbol: [ "QSGGeometryNode", "private", "<QSGGeometryNode>", "public" ] },
+    { symbol: [ "QSGMaterial", "private", "<QSGMaterial>", "public" ] },
+    { symbol: [ "QSGMaterialShader", "private", "<QSGMaterialShader>", "public" ] },
+    { symbol: [ "QSGMaterialType", "private", "<QSGMaterialType>", "public" ] },
+    { symbol: [ "QSGNode", "private", "<QSGNode>", "public" ] },
+    { symbol: [ "QSGNodeVisitor", "private", "<QSGNodeVisitor>", "public" ] },
+    { symbol: [ "QSGOpacityNode", "private", "<QSGOpacityNode>", "public" ] },
+    { symbol: [ "QSGOpaqueTextureMaterial", "private", "<QSGOpaqueTextureMaterial>", "public" ] },
+    { symbol: [ "QSGRootNode", "private", "<QSGRootNode>", "public" ] },
+    { symbol: [ "QSGSimpleMaterial", "private", "<QSGSimpleMaterial>", "public" ] },
+    { symbol: [ "QSGSimpleMaterialComparableMaterial", "private", "<QSGSimpleMaterialComparableMaterial>", "public" ] },
+    { symbol: [ "QSGSimpleMaterialShader", "private", "<QSGSimpleMaterialShader>", "public" ] },
+    { symbol: [ "QSGSimpleRectNode", "private", "<QSGSimpleRectNode>", "public" ] },
+    { symbol: [ "QSGSimpleTextureNode", "private", "<QSGSimpleTextureNode>", "public" ] },
+    { symbol: [ "QSGTexture", "private", "<QSGTexture>", "public" ] },
+    { symbol: [ "QSGTextureMaterial", "private", "<QSGTextureMaterial>", "public" ] },
+    { symbol: [ "QSGTextureProvider", "private", "<QSGTextureProvider>", "public" ] },
+    { symbol: [ "QSGTransformNode", "private", "<QSGTransformNode>", "public" ] },
+    { symbol: [ "QSGVertexColorMaterial", "private", "<QSGVertexColorMaterial>", "public" ] },
+    { symbol: [ "QSGVideoNodeFactory_I420", "private", "<QSGVideoNodeFactory_I420>", "public" ] },
+    { symbol: [ "QSGVideoNodeFactory_RGB", "private", "<QSGVideoNodeFactory_RGB>", "public" ] },
+    { symbol: [ "QSGVideoNodeFactory_Texture", "private", "<QSGVideoNodeFactory_Texture>", "public" ] },
+    { symbol: [ "QSGVideoNode_I420", "private", "<QSGVideoNode_I420>", "public" ] },
+    { symbol: [ "QSGVideoNode_RGB", "private", "<QSGVideoNode_RGB>", "public" ] },
+    { symbol: [ "QSGVideoNode_Texture", "private", "<QSGVideoNode_Texture>", "public" ] },
+    { symbol: [ "QSaveFile", "private", "<QSaveFile>", "public" ] },
+    { symbol: [ "QScopedArrayPointer", "private", "<QScopedArrayPointer>", "public" ] },
+    { symbol: [ "QScopedPointer", "private", "<QScopedPointer>", "public" ] },
+    { symbol: [ "QScopedPointerArrayDeleter", "private", "<QScopedPointerArrayDeleter>", "public" ] },
+    { symbol: [ "QScopedPointerDeleteLater", "private", "<QScopedPointerDeleteLater>", "public" ] },
+    { symbol: [ "QScopedPointerDeleter", "private", "<QScopedPointerDeleter>", "public" ] },
+    { symbol: [ "QScopedPointerObjectDeleteLater", "private", "<QScopedPointerObjectDeleteLater>", "public" ] },
+    { symbol: [ "QScopedPointerPodDeleter", "private", "<QScopedPointerPodDeleter>", "public" ] },
+    { symbol: [ "QScopedValueRollback", "private", "<QScopedValueRollback>", "public" ] },
+    { symbol: [ "QScreen", "private", "<QScreen>", "public" ] },
+    { symbol: [ "QScreenOrientationChangeEvent", "private", "<QScreenOrientationChangeEvent>", "public" ] },
+    { symbol: [ "QScriptClass", "private", "<QScriptClass>", "public" ] },
+    { symbol: [ "QScriptClassPropertyIterator", "private", "<QScriptClassPropertyIterator>", "public" ] },
+    { symbol: [ "QScriptContext", "private", "<QScriptContext>", "public" ] },
+    { symbol: [ "QScriptContextInfo", "private", "<QScriptContextInfo>", "public" ] },
+    { symbol: [ "QScriptContextInfoList", "private", "<QScriptContextInfoList>", "public" ] },
+    { symbol: [ "QScriptEngine", "private", "<QScriptEngine>", "public" ] },
+    { symbol: [ "QScriptEngineAgent", "private", "<QScriptEngineAgent>", "public" ] },
+    { symbol: [ "QScriptEngineDebugger", "private", "<QScriptEngineDebugger>", "public" ] },
+    { symbol: [ "QScriptExtensionInterface", "private", "<QScriptExtensionInterface>", "public" ] },
+    { symbol: [ "QScriptExtensionPlugin", "private", "<QScriptExtensionPlugin>", "public" ] },
+    { symbol: [ "QScriptProgram", "private", "<QScriptProgram>", "public" ] },
+    { symbol: [ "QScriptString", "private", "<QScriptString>", "public" ] },
+    { symbol: [ "QScriptSyntaxCheckResult", "private", "<QScriptSyntaxCheckResult>", "public" ] },
+    { symbol: [ "QScriptValue", "private", "<QScriptValue>", "public" ] },
+    { symbol: [ "QScriptValueIterator", "private", "<QScriptValueIterator>", "public" ] },
+    { symbol: [ "QScriptValueList", "private", "<QScriptValueList>", "public" ] },
+    { symbol: [ "QScriptable", "private", "<QScriptable>", "public" ] },
+    { symbol: [ "QScrollArea", "private", "<QScrollArea>", "public" ] },
+    { symbol: [ "QScrollBar", "private", "<QScrollBar>", "public" ] },
+    { symbol: [ "QScrollEvent", "private", "<QScrollEvent>", "public" ] },
+    { symbol: [ "QScrollPrepareEvent", "private", "<QScrollPrepareEvent>", "public" ] },
+    { symbol: [ "QScroller", "private", "<QScroller>", "public" ] },
+    { symbol: [ "QScrollerProperties", "private", "<QScrollerProperties>", "public" ] },
+    { symbol: [ "QSemaphore", "private", "<QSemaphore>", "public" ] },
+    { symbol: [ "QSensor", "private", "<QSensor>", "public" ] },
+    { symbol: [ "QSensorBackend", "private", "<QSensorBackend>", "public" ] },
+    { symbol: [ "QSensorBackendFactory", "private", "<QSensorBackendFactory>", "public" ] },
+    { symbol: [ "QSensorChangesInterface", "private", "<QSensorChangesInterface>", "public" ] },
+    { symbol: [ "QSensorFilter", "private", "<QSensorFilter>", "public" ] },
+    { symbol: [ "QSensorGesture", "private", "<QSensorGesture>", "public" ] },
+    { symbol: [ "QSensorGestureManager", "private", "<QSensorGestureManager>", "public" ] },
+    { symbol: [ "QSensorGesturePluginInterface", "private", "<QSensorGesturePluginInterface>", "public" ] },
+    { symbol: [ "QSensorGestureRecognizer", "private", "<QSensorGestureRecognizer>", "public" ] },
+    { symbol: [ "QSensorManager", "private", "<QSensorManager>", "public" ] },
+    { symbol: [ "QSensorPluginInterface", "private", "<QSensorPluginInterface>", "public" ] },
+    { symbol: [ "QSensorReading", "private", "<QSensorReading>", "public" ] },
+    { symbol: [ "QSequentialAnimationGroup", "private", "<QSequentialAnimationGroup>", "public" ] },
+    { symbol: [ "QSequentialIterable", "private", "<QSequentialIterable>", "public" ] },
+    { symbol: [ "QSerialPort", "private", "<QSerialPort>", "public" ] },
+    { symbol: [ "QSerialPortInfo", "private", "<QSerialPortInfo>", "public" ] },
+    { symbol: [ "QSessionManager", "private", "<QSessionManager>", "public" ] },
+    { symbol: [ "QSet", "private", "<QSet>", "public" ] },
+    { symbol: [ "QSetIterator", "private", "<QSetIterator>", "public" ] },
+    { symbol: [ "QSettings", "private", "<QSettings>", "public" ] },
+    { symbol: [ "QSharedData", "private", "<QSharedData>", "public" ] },
+    { symbol: [ "QSharedDataPointer", "private", "<QSharedDataPointer>", "public" ] },
+    { symbol: [ "QSharedMemory", "private", "<QSharedMemory>", "public" ] },
+    { symbol: [ "QSharedPointer", "private", "<QSharedPointer>", "public" ] },
+    { symbol: [ "QShortcut", "private", "<QShortcut>", "public" ] },
+    { symbol: [ "QShortcutEvent", "private", "<QShortcutEvent>", "public" ] },
+    { symbol: [ "QShowEvent", "private", "<QShowEvent>", "public" ] },
+    { symbol: [ "QSignalBlocker", "private", "<QSignalBlocker>", "public" ] },
+    { symbol: [ "QSignalMapper", "private", "<QSignalMapper>", "public" ] },
+    { symbol: [ "QSignalSpy", "private", "<QSignalSpy>", "public" ] },
+    { symbol: [ "QSignalTransition", "private", "<QSignalTransition>", "public" ] },
+    { symbol: [ "QSimpleXmlNodeModel", "private", "<QSimpleXmlNodeModel>", "public" ] },
+    { symbol: [ "QSize", "private", "<QSize>", "public" ] },
+    { symbol: [ "QSizeF", "private", "<QSizeF>", "public" ] },
+    { symbol: [ "QSizeGrip", "private", "<QSizeGrip>", "public" ] },
+    { symbol: [ "QSizePolicy", "private", "<QSizePolicy>", "public" ] },
+    { symbol: [ "QSlider", "private", "<QSlider>", "public" ] },
+    { symbol: [ "QSocketNotifier", "private", "<QSocketNotifier>", "public" ] },
+    { symbol: [ "QSortFilterProxyModel", "private", "<QSortFilterProxyModel>", "public" ] },
+    { symbol: [ "QSound", "private", "<QSound>", "public" ] },
+    { symbol: [ "QSoundEffect", "private", "<QSoundEffect>", "public" ] },
+    { symbol: [ "QSourceLocation", "private", "<QSourceLocation>", "public" ] },
+    { symbol: [ "QSpacerItem", "private", "<QSpacerItem>", "public" ] },
+    { symbol: [ "QSpinBox", "private", "<QSpinBox>", "public" ] },
+    { symbol: [ "QSplashScreen", "private", "<QSplashScreen>", "public" ] },
+    { symbol: [ "QSplitter", "private", "<QSplitter>", "public" ] },
+    { symbol: [ "QSplitterHandle", "private", "<QSplitterHandle>", "public" ] },
+    { symbol: [ "QSpontaneKeyEvent", "private", "<QSpontaneKeyEvent>", "public" ] },
+    { symbol: [ "QSql", "private", "<QSql>", "public" ] },
+    { symbol: [ "QSqlDatabase", "private", "<QSqlDatabase>", "public" ] },
+    { symbol: [ "QSqlDriver", "private", "<QSqlDriver>", "public" ] },
+    { symbol: [ "QSqlDriverCreator", "private", "<QSqlDriverCreator>", "public" ] },
+    { symbol: [ "QSqlDriverCreatorBase", "private", "<QSqlDriverCreatorBase>", "public" ] },
+    { symbol: [ "QSqlDriverPlugin", "private", "<QSqlDriverPlugin>", "public" ] },
+    { symbol: [ "QSqlError", "private", "<QSqlError>", "public" ] },
+    { symbol: [ "QSqlField", "private", "<QSqlField>", "public" ] },
+    { symbol: [ "QSqlIndex", "private", "<QSqlIndex>", "public" ] },
+    { symbol: [ "QSqlQuery", "private", "<QSqlQuery>", "public" ] },
+    { symbol: [ "QSqlQueryModel", "private", "<QSqlQueryModel>", "public" ] },
+    { symbol: [ "QSqlRecord", "private", "<QSqlRecord>", "public" ] },
+    { symbol: [ "QSqlRelation", "private", "<QSqlRelation>", "public" ] },
+    { symbol: [ "QSqlRelationalDelegate", "private", "<QSqlRelationalDelegate>", "public" ] },
+    { symbol: [ "QSqlRelationalTableModel", "private", "<QSqlRelationalTableModel>", "public" ] },
+    { symbol: [ "QSqlResult", "private", "<QSqlResult>", "public" ] },
+    { symbol: [ "QSqlTableModel", "private", "<QSqlTableModel>", "public" ] },
+    { symbol: [ "QSsl", "private", "<QSsl>", "public" ] },
+    { symbol: [ "QSslCertificate", "private", "<QSslCertificate>", "public" ] },
+    { symbol: [ "QSslCertificateExtension", "private", "<QSslCertificateExtension>", "public" ] },
+    { symbol: [ "QSslCipher", "private", "<QSslCipher>", "public" ] },
+    { symbol: [ "QSslConfiguration", "private", "<QSslConfiguration>", "public" ] },
+    { symbol: [ "QSslError", "private", "<QSslError>", "public" ] },
+    { symbol: [ "QSslKey", "private", "<QSslKey>", "public" ] },
+    { symbol: [ "QSslSocket", "private", "<QSslSocket>", "public" ] },
+    { symbol: [ "QStack", "private", "<QStack>", "public" ] },
+    { symbol: [ "QStackedLayout", "private", "<QStackedLayout>", "public" ] },
+    { symbol: [ "QStackedWidget", "private", "<QStackedWidget>", "public" ] },
+    { symbol: [ "QStandardItem", "private", "<QStandardItem>", "public" ] },
+    { symbol: [ "QStandardItemEditorCreator", "private", "<QStandardItemEditorCreator>", "public" ] },
+    { symbol: [ "QStandardItemModel", "private", "<QStandardItemModel>", "public" ] },
+    { symbol: [ "QStandardPaths", "private", "<QStandardPaths>", "public" ] },
+    { symbol: [ "QState", "private", "<QState>", "public" ] },
+    { symbol: [ "QStateMachine", "private", "<QStateMachine>", "public" ] },
+    { symbol: [ "QStaticArrayData", "private", "<QStaticArrayData>", "public" ] },
+    { symbol: [ "QStaticAssertFailure", "private", "<QStaticAssertFailure>", "public" ] },
+    { symbol: [ "QStaticByteArrayData", "private", "<QStaticByteArrayData>", "public" ] },
+    { symbol: [ "QStaticPlugin", "private", "<QStaticPlugin>", "public" ] },
+    { symbol: [ "QStaticStringData", "private", "<QStaticStringData>", "public" ] },
+    { symbol: [ "QStaticText", "private", "<QStaticText>", "public" ] },
+    { symbol: [ "QStatusBar", "private", "<QStatusBar>", "public" ] },
+    { symbol: [ "QStatusTipEvent", "private", "<QStatusTipEvent>", "public" ] },
+    { symbol: [ "QStorageInfo", "private", "<QStorageInfo>", "public" ] },
+    { symbol: [ "QString", "private", "<QString>", "public" ] },
+    { symbol: [ "QStringBuilder", "private", "<QStringBuilder>", "public" ] },
+    { symbol: [ "QStringData", "private", "<QStringData>", "public" ] },
+    { symbol: [ "QStringDataPtr", "private", "<QStringDataPtr>", "public" ] },
+    { symbol: [ "QStringList", "private", "<QStringList>", "public" ] },
+    { symbol: [ "QStringListIterator", "private", "<QStringListIterator>", "public" ] },
+    { symbol: [ "QStringListModel", "private", "<QStringListModel>", "public" ] },
+    { symbol: [ "QStringMatcher", "private", "<QStringMatcher>", "public" ] },
+    { symbol: [ "QStringRef", "private", "<QStringRef>", "public" ] },
+    { symbol: [ "QStyle", "private", "<QStyle>", "public" ] },
+    { symbol: [ "QStyleFactory", "private", "<QStyleFactory>", "public" ] },
+    { symbol: [ "QStyleHintReturn", "private", "<QStyleHintReturn>", "public" ] },
+    { symbol: [ "QStyleHintReturnMask", "private", "<QStyleHintReturnMask>", "public" ] },
+    { symbol: [ "QStyleHintReturnVariant", "private", "<QStyleHintReturnVariant>", "public" ] },
+    { symbol: [ "QStyleHints", "private", "<QStyleHints>", "public" ] },
+    { symbol: [ "QStyleOption", "private", "<QStyleOption>", "public" ] },
+    { symbol: [ "QStyleOptionButton", "private", "<QStyleOptionButton>", "public" ] },
+    { symbol: [ "QStyleOptionComboBox", "private", "<QStyleOptionComboBox>", "public" ] },
+    { symbol: [ "QStyleOptionComplex", "private", "<QStyleOptionComplex>", "public" ] },
+    { symbol: [ "QStyleOptionDockWidget", "private", "<QStyleOptionDockWidget>", "public" ] },
+    { symbol: [ "QStyleOptionDockWidgetV2", "private", "<QStyleOptionDockWidgetV2>", "public" ] },
+    { symbol: [ "QStyleOptionFocusRect", "private", "<QStyleOptionFocusRect>", "public" ] },
+    { symbol: [ "QStyleOptionFrame", "private", "<QStyleOptionFrame>", "public" ] },
+    { symbol: [ "QStyleOptionFrameV2", "private", "<QStyleOptionFrameV2>", "public" ] },
+    { symbol: [ "QStyleOptionFrameV3", "private", "<QStyleOptionFrameV3>", "public" ] },
+    { symbol: [ "QStyleOptionGraphicsItem", "private", "<QStyleOptionGraphicsItem>", "public" ] },
+    { symbol: [ "QStyleOptionGroupBox", "private", "<QStyleOptionGroupBox>", "public" ] },
+    { symbol: [ "QStyleOptionHeader", "private", "<QStyleOptionHeader>", "public" ] },
+    { symbol: [ "QStyleOptionMenuItem", "private", "<QStyleOptionMenuItem>", "public" ] },
+    { symbol: [ "QStyleOptionProgressBar", "private", "<QStyleOptionProgressBar>", "public" ] },
+    { symbol: [ "QStyleOptionProgressBarV2", "private", "<QStyleOptionProgressBarV2>", "public" ] },
+    { symbol: [ "QStyleOptionRubberBand", "private", "<QStyleOptionRubberBand>", "public" ] },
+    { symbol: [ "QStyleOptionSizeGrip", "private", "<QStyleOptionSizeGrip>", "public" ] },
+    { symbol: [ "QStyleOptionSlider", "private", "<QStyleOptionSlider>", "public" ] },
+    { symbol: [ "QStyleOptionSpinBox", "private", "<QStyleOptionSpinBox>", "public" ] },
+    { symbol: [ "QStyleOptionTab", "private", "<QStyleOptionTab>", "public" ] },
+    { symbol: [ "QStyleOptionTabBarBase", "private", "<QStyleOptionTabBarBase>", "public" ] },
+    { symbol: [ "QStyleOptionTabBarBaseV2", "private", "<QStyleOptionTabBarBaseV2>", "public" ] },
+    { symbol: [ "QStyleOptionTabV2", "private", "<QStyleOptionTabV2>", "public" ] },
+    { symbol: [ "QStyleOptionTabV3", "private", "<QStyleOptionTabV3>", "public" ] },
+    { symbol: [ "QStyleOptionTabWidgetFrame", "private", "<QStyleOptionTabWidgetFrame>", "public" ] },
+    { symbol: [ "QStyleOptionTabWidgetFrameV2", "private", "<QStyleOptionTabWidgetFrameV2>", "public" ] },
+    { symbol: [ "QStyleOptionTitleBar", "private", "<QStyleOptionTitleBar>", "public" ] },
+    { symbol: [ "QStyleOptionToolBar", "private", "<QStyleOptionToolBar>", "public" ] },
+    { symbol: [ "QStyleOptionToolBox", "private", "<QStyleOptionToolBox>", "public" ] },
+    { symbol: [ "QStyleOptionToolBoxV2", "private", "<QStyleOptionToolBoxV2>", "public" ] },
+    { symbol: [ "QStyleOptionToolButton", "private", "<QStyleOptionToolButton>", "public" ] },
+    { symbol: [ "QStyleOptionViewItem", "private", "<QStyleOptionViewItem>", "public" ] },
+    { symbol: [ "QStyleOptionViewItemV2", "private", "<QStyleOptionViewItemV2>", "public" ] },
+    { symbol: [ "QStyleOptionViewItemV3", "private", "<QStyleOptionViewItemV3>", "public" ] },
+    { symbol: [ "QStyleOptionViewItemV4", "private", "<QStyleOptionViewItemV4>", "public" ] },
+    { symbol: [ "QStylePainter", "private", "<QStylePainter>", "public" ] },
+    { symbol: [ "QStylePlugin", "private", "<QStylePlugin>", "public" ] },
+    { symbol: [ "QStyledItemDelegate", "private", "<QStyledItemDelegate>", "public" ] },
+    { symbol: [ "QSurface", "private", "<QSurface>", "public" ] },
+    { symbol: [ "QSurfaceFormat", "private", "<QSurfaceFormat>", "public" ] },
+    { symbol: [ "QSvgGenerator", "private", "<QSvgGenerator>", "public" ] },
+    { symbol: [ "QSvgRenderer", "private", "<QSvgRenderer>", "public" ] },
+    { symbol: [ "QSvgWidget", "private", "<QSvgWidget>", "public" ] },
+    { symbol: [ "QSwipeGesture", "private", "<QSwipeGesture>", "public" ] },
+    { symbol: [ "QSyntaxHighlighter", "private", "<QSyntaxHighlighter>", "public" ] },
+    { symbol: [ "QSysInfo", "private", "<QSysInfo>", "public" ] },
+    { symbol: [ "QSystemSemaphore", "private", "<QSystemSemaphore>", "public" ] },
+    { symbol: [ "QSystemTrayIcon", "private", "<QSystemTrayIcon>", "public" ] },
+    { symbol: [ "QTabBar", "private", "<QTabBar>", "public" ] },
+    { symbol: [ "QTabWidget", "private", "<QTabWidget>", "public" ] },
+    { symbol: [ "QTableView", "private", "<QTableView>", "public" ] },
+    { symbol: [ "QTableWidget", "private", "<QTableWidget>", "public" ] },
+    { symbol: [ "QTableWidgetItem", "private", "<QTableWidgetItem>", "public" ] },
+    { symbol: [ "QTableWidgetSelectionRange", "private", "<QTableWidgetSelectionRange>", "public" ] },
+    { symbol: [ "QTabletEvent", "private", "<QTabletEvent>", "public" ] },
+    { symbol: [ "QTapAndHoldGesture", "private", "<QTapAndHoldGesture>", "public" ] },
+    { symbol: [ "QTapFilter", "private", "<QTapFilter>", "public" ] },
+    { symbol: [ "QTapGesture", "private", "<QTapGesture>", "public" ] },
+    { symbol: [ "QTapReading", "private", "<QTapReading>", "public" ] },
+    { symbol: [ "QTapSensor", "private", "<QTapSensor>", "public" ] },
+    { symbol: [ "QTcpServer", "private", "<QTcpServer>", "public" ] },
+    { symbol: [ "QTcpSocket", "private", "<QTcpSocket>", "public" ] },
+    { symbol: [ "QTemporaryDir", "private", "<QTemporaryDir>", "public" ] },
+    { symbol: [ "QTemporaryFile", "private", "<QTemporaryFile>", "public" ] },
+    { symbol: [ "QTest", "private", "<QTest>", "public" ] },
+    { symbol: [ "QTestAccessibility", "private", "<QTestAccessibility>", "public" ] },
+    { symbol: [ "QTestData", "private", "<QTestData>", "public" ] },
+    { symbol: [ "QTestDelayEvent", "private", "<QTestDelayEvent>", "public" ] },
+    { symbol: [ "QTestEvent", "private", "<QTestEvent>", "public" ] },
+    { symbol: [ "QTestEventList", "private", "<QTestEventList>", "public" ] },
+    { symbol: [ "QTestEventLoop", "private", "<QTestEventLoop>", "public" ] },
+    { symbol: [ "QTestKeyClicksEvent", "private", "<QTestKeyClicksEvent>", "public" ] },
+    { symbol: [ "QTestKeyEvent", "private", "<QTestKeyEvent>", "public" ] },
+    { symbol: [ "QTestMouseEvent", "private", "<QTestMouseEvent>", "public" ] },
+    { symbol: [ "QTextBlock", "private", "<QTextBlock>", "public" ] },
+    { symbol: [ "QTextBlockFormat", "private", "<QTextBlockFormat>", "public" ] },
+    { symbol: [ "QTextBlockGroup", "private", "<QTextBlockGroup>", "public" ] },
+    { symbol: [ "QTextBlockUserData", "private", "<QTextBlockUserData>", "public" ] },
+    { symbol: [ "QTextBoundaryFinder", "private", "<QTextBoundaryFinder>", "public" ] },
+    { symbol: [ "QTextBrowser", "private", "<QTextBrowser>", "public" ] },
+    { symbol: [ "QTextCharFormat", "private", "<QTextCharFormat>", "public" ] },
+    { symbol: [ "QTextCodec", "private", "<QTextCodec>", "public" ] },
+    { symbol: [ "QTextCursor", "private", "<QTextCursor>", "public" ] },
+    { symbol: [ "QTextDecoder", "private", "<QTextDecoder>", "public" ] },
+    { symbol: [ "QTextDocument", "private", "<QTextDocument>", "public" ] },
+    { symbol: [ "QTextDocumentFragment", "private", "<QTextDocumentFragment>", "public" ] },
+    { symbol: [ "QTextDocumentWriter", "private", "<QTextDocumentWriter>", "public" ] },
+    { symbol: [ "QTextEdit", "private", "<QTextEdit>", "public" ] },
+    { symbol: [ "QTextEncoder", "private", "<QTextEncoder>", "public" ] },
+    { symbol: [ "QTextFormat", "private", "<QTextFormat>", "public" ] },
+    { symbol: [ "QTextFragment", "private", "<QTextFragment>", "public" ] },
+    { symbol: [ "QTextFrame", "private", "<QTextFrame>", "public" ] },
+    { symbol: [ "QTextFrameFormat", "private", "<QTextFrameFormat>", "public" ] },
+    { symbol: [ "QTextFrameLayoutData", "private", "<QTextFrameLayoutData>", "public" ] },
+    { symbol: [ "QTextImageFormat", "private", "<QTextImageFormat>", "public" ] },
+    { symbol: [ "QTextInlineObject", "private", "<QTextInlineObject>", "public" ] },
+    { symbol: [ "QTextItem", "private", "<QTextItem>", "public" ] },
+    { symbol: [ "QTextLayout", "private", "<QTextLayout>", "public" ] },
+    { symbol: [ "QTextLength", "private", "<QTextLength>", "public" ] },
+    { symbol: [ "QTextLine", "private", "<QTextLine>", "public" ] },
+    { symbol: [ "QTextList", "private", "<QTextList>", "public" ] },
+    { symbol: [ "QTextListFormat", "private", "<QTextListFormat>", "public" ] },
+    { symbol: [ "QTextObject", "private", "<QTextObject>", "public" ] },
+    { symbol: [ "QTextObjectInterface", "private", "<QTextObjectInterface>", "public" ] },
+    { symbol: [ "QTextOption", "private", "<QTextOption>", "public" ] },
+    { symbol: [ "QTextStream", "private", "<QTextStream>", "public" ] },
+    { symbol: [ "QTextStreamFunction", "private", "<QTextStreamFunction>", "public" ] },
+    { symbol: [ "QTextStreamManipulator", "private", "<QTextStreamManipulator>", "public" ] },
+    { symbol: [ "QTextTable", "private", "<QTextTable>", "public" ] },
+    { symbol: [ "QTextTableCell", "private", "<QTextTableCell>", "public" ] },
+    { symbol: [ "QTextTableCellFormat", "private", "<QTextTableCellFormat>", "public" ] },
+    { symbol: [ "QTextTableFormat", "private", "<QTextTableFormat>", "public" ] },
+    { symbol: [ "QThread", "private", "<QThread>", "public" ] },
+    { symbol: [ "QThreadPool", "private", "<QThreadPool>", "public" ] },
+    { symbol: [ "QThreadStorage", "private", "<QThreadStorage>", "public" ] },
+    { symbol: [ "QThreadStorageData", "private", "<QThreadStorageData>", "public" ] },
+    { symbol: [ "QTileRules", "private", "<QTileRules>", "public" ] },
+    { symbol: [ "QTiltFilter", "private", "<QTiltFilter>", "public" ] },
+    { symbol: [ "QTiltReading", "private", "<QTiltReading>", "public" ] },
+    { symbol: [ "QTiltSensor", "private", "<QTiltSensor>", "public" ] },
+    { symbol: [ "QTime", "private", "<QTime>", "public" ] },
+    { symbol: [ "QTimeEdit", "private", "<QTimeEdit>", "public" ] },
+    { symbol: [ "QTimeLine", "private", "<QTimeLine>", "public" ] },
+    { symbol: [ "QTimeZone", "private", "<QTimeZone>", "public" ] },
+    { symbol: [ "QTimer", "private", "<QTimer>", "public" ] },
+    { symbol: [ "QTimerEvent", "private", "<QTimerEvent>", "public" ] },
+    { symbol: [ "QToolBar", "private", "<QToolBar>", "public" ] },
+    { symbol: [ "QToolBarChangeEvent", "private", "<QToolBarChangeEvent>", "public" ] },
+    { symbol: [ "QToolBox", "private", "<QToolBox>", "public" ] },
+    { symbol: [ "QToolButton", "private", "<QToolButton>", "public" ] },
+    { symbol: [ "QToolTip", "private", "<QToolTip>", "public" ] },
+    { symbol: [ "QTouchDevice", "private", "<QTouchDevice>", "public" ] },
+    { symbol: [ "QTouchEvent", "private", "<QTouchEvent>", "public" ] },
+    { symbol: [ "QTransform", "private", "<QTransform>", "public" ] },
+    { symbol: [ "QTranslator", "private", "<QTranslator>", "public" ] },
+    { symbol: [ "QTreeView", "private", "<QTreeView>", "public" ] },
+    { symbol: [ "QTreeWidget", "private", "<QTreeWidget>", "public" ] },
+    { symbol: [ "QTreeWidgetItem", "private", "<QTreeWidgetItem>", "public" ] },
+    { symbol: [ "QTreeWidgetItemIterator", "private", "<QTreeWidgetItemIterator>", "public" ] },
+    { symbol: [ "QTypeInfo", "private", "<QTypeInfo>", "public" ] },
+    { symbol: [ "QTypeInfoMerger", "private", "<QTypeInfoMerger>", "public" ] },
+    { symbol: [ "QUdpSocket", "private", "<QUdpSocket>", "public" ] },
+    { symbol: [ "QUiLoader", "private", "<QUiLoader>", "public" ] },
+    { symbol: [ "QUndoCommand", "private", "<QUndoCommand>", "public" ] },
+    { symbol: [ "QUndoGroup", "private", "<QUndoGroup>", "public" ] },
+    { symbol: [ "QUndoStack", "private", "<QUndoStack>", "public" ] },
+    { symbol: [ "QUndoView", "private", "<QUndoView>", "public" ] },
+    { symbol: [ "QUnhandledException", "private", "<QUnhandledException>", "public" ] },
+    { symbol: [ "QUrl", "private", "<QUrl>", "public" ] },
+    { symbol: [ "QUrlQuery", "private", "<QUrlQuery>", "public" ] },
+    { symbol: [ "QUrlTwoFlags", "private", "<QUrlTwoFlags>", "public" ] },
+    { symbol: [ "QUuid", "private", "<QUuid>", "public" ] },
+    { symbol: [ "QVBoxLayout", "private", "<QVBoxLayout>", "public" ] },
+    { symbol: [ "QValidator", "private", "<QValidator>", "public" ] },
+    { symbol: [ "QVarLengthArray", "private", "<QVarLengthArray>", "public" ] },
+    { symbol: [ "QVariant", "private", "<QVariant>", "public" ] },
+    { symbol: [ "QVariantAnimation", "private", "<QVariantAnimation>", "public" ] },
+    { symbol: [ "QVariantComparisonHelper", "private", "<QVariantComparisonHelper>", "public" ] },
+    { symbol: [ "QVariantHash", "private", "<QVariantHash>", "public" ] },
+    { symbol: [ "QVariantList", "private", "<QVariantList>", "public" ] },
+    { symbol: [ "QVariantMap", "private", "<QVariantMap>", "public" ] },
+    { symbol: [ "QVector", "private", "<QVector>", "public" ] },
+    { symbol: [ "QVector2D", "private", "<QVector2D>", "public" ] },
+    { symbol: [ "QVector3D", "private", "<QVector3D>", "public" ] },
+    { symbol: [ "QVector4D", "private", "<QVector4D>", "public" ] },
+    { symbol: [ "QVectorIterator", "private", "<QVectorIterator>", "public" ] },
+    { symbol: [ "QVideoDeviceSelectorControl", "private", "<QVideoDeviceSelectorControl>", "public" ] },
+    { symbol: [ "QVideoEncoderSettings", "private", "<QVideoEncoderSettings>", "public" ] },
+    { symbol: [ "QVideoEncoderSettingsControl", "private", "<QVideoEncoderSettingsControl>", "public" ] },
+    { symbol: [ "QVideoFrame", "private", "<QVideoFrame>", "public" ] },
+    { symbol: [ "QVideoProbe", "private", "<QVideoProbe>", "public" ] },
+    { symbol: [ "QVideoRendererControl", "private", "<QVideoRendererControl>", "public" ] },
+    { symbol: [ "QVideoSurfaceFormat", "private", "<QVideoSurfaceFormat>", "public" ] },
+    { symbol: [ "QVideoWidget", "private", "<QVideoWidget>", "public" ] },
+    { symbol: [ "QVideoWidgetControl", "private", "<QVideoWidgetControl>", "public" ] },
+    { symbol: [ "QVideoWindowControl", "private", "<QVideoWindowControl>", "public" ] },
+    { symbol: [ "QWGLNativeContext", "private", "<QWGLNativeContext>", "public" ] },
+    { symbol: [ "QWaitCondition", "private", "<QWaitCondition>", "public" ] },
+    { symbol: [ "QWeakPointer", "private", "<QWeakPointer>", "public" ] },
+    { symbol: [ "QWebChannel", "private", "<QWebChannel>", "public" ] },
+    { symbol: [ "QWebChannelAbstractTransport", "private", "<QWebChannelAbstractTransport>", "public" ] },
+    { symbol: [ "QWebDatabase", "private", "<QWebDatabase>", "public" ] },
+    { symbol: [ "QWebElement", "private", "<QWebElement>", "public" ] },
+    { symbol: [ "QWebElementCollection", "private", "<QWebElementCollection>", "public" ] },
+    { symbol: [ "QWebFrame", "private", "<QWebFrame>", "public" ] },
+    { symbol: [ "QWebFullScreenVideoHandler", "private", "<QWebFullScreenVideoHandler>", "public" ] },
+    { symbol: [ "QWebHapticFeedbackPlayer", "private", "<QWebHapticFeedbackPlayer>", "public" ] },
+    { symbol: [ "QWebHistory", "private", "<QWebHistory>", "public" ] },
+    { symbol: [ "QWebHistoryInterface", "private", "<QWebHistoryInterface>", "public" ] },
+    { symbol: [ "QWebHistoryItem", "private", "<QWebHistoryItem>", "public" ] },
+    { symbol: [ "QWebHitTestResult", "private", "<QWebHitTestResult>", "public" ] },
+    { symbol: [ "QWebInspector", "private", "<QWebInspector>", "public" ] },
+    { symbol: [ "QWebKitPlatformPlugin", "private", "<QWebKitPlatformPlugin>", "public" ] },
+    { symbol: [ "QWebNotificationData", "private", "<QWebNotificationData>", "public" ] },
+    { symbol: [ "QWebNotificationPresenter", "private", "<QWebNotificationPresenter>", "public" ] },
+    { symbol: [ "QWebPage", "private", "<QWebPage>", "public" ] },
+    { symbol: [ "QWebPluginFactory", "private", "<QWebPluginFactory>", "public" ] },
+    { symbol: [ "QWebSecurityOrigin", "private", "<QWebSecurityOrigin>", "public" ] },
+    { symbol: [ "QWebSelectData", "private", "<QWebSelectData>", "public" ] },
+    { symbol: [ "QWebSelectMethod", "private", "<QWebSelectMethod>", "public" ] },
+    { symbol: [ "QWebSettings", "private", "<QWebSettings>", "public" ] },
+    { symbol: [ "QWebSocket", "private", "<QWebSocket>", "public" ] },
+    { symbol: [ "QWebSocketCorsAuthenticator", "private", "<QWebSocketCorsAuthenticator>", "public" ] },
+    { symbol: [ "QWebSocketServer", "private", "<QWebSocketServer>", "public" ] },
+    { symbol: [ "QWebSpellChecker", "private", "<QWebSpellChecker>", "public" ] },
+    { symbol: [ "QWebTouchModifier", "private", "<QWebTouchModifier>", "public" ] },
+    { symbol: [ "QWebView", "private", "<QWebView>", "public" ] },
+    { symbol: [ "QWhatsThis", "private", "<QWhatsThis>", "public" ] },
+    { symbol: [ "QWhatsThisClickedEvent", "private", "<QWhatsThisClickedEvent>", "public" ] },
+    { symbol: [ "QWheelEvent", "private", "<QWheelEvent>", "public" ] },
+    { symbol: [ "QWidget", "private", "<QWidget>", "public" ] },
+    { symbol: [ "QWidgetAction", "private", "<QWidgetAction>", "public" ] },
+    { symbol: [ "QWidgetData", "private", "<QWidgetData>", "public" ] },
+    { symbol: [ "QWidgetItem", "private", "<QWidgetItem>", "public" ] },
+    { symbol: [ "QWidgetItemV2", "private", "<QWidgetItemV2>", "public" ] },
+    { symbol: [ "QWidgetList", "private", "<QWidgetList>", "public" ] },
+    { symbol: [ "QWidgetMapper", "private", "<QWidgetMapper>", "public" ] },
+    { symbol: [ "QWidgetSet", "private", "<QWidgetSet>", "public" ] },
+    { symbol: [ "QWinColorizationChangeEvent", "private", "<QWinColorizationChangeEvent>", "public" ] },
+    { symbol: [ "QWinCompositionChangeEvent", "private", "<QWinCompositionChangeEvent>", "public" ] },
+    { symbol: [ "QWinEvent", "private", "<QWinEvent>", "public" ] },
+    { symbol: [ "QWinEventNotifier", "private", "<QWinEventNotifier>", "public" ] },
+    { symbol: [ "QWinEventNotifier", "private", "<QWinEventNotifier>", "public" ] },
+    { symbol: [ "QWinJumpList", "private", "<QWinJumpList>", "public" ] },
+    { symbol: [ "QWinJumpListCategory", "private", "<QWinJumpListCategory>", "public" ] },
+    { symbol: [ "QWinJumpListItem", "private", "<QWinJumpListItem>", "public" ] },
+    { symbol: [ "QWinMime", "private", "<QWinMime>", "public" ] },
+    { symbol: [ "QWinTaskbarButton", "private", "<QWinTaskbarButton>", "public" ] },
+    { symbol: [ "QWinTaskbarProgress", "private", "<QWinTaskbarProgress>", "public" ] },
+    { symbol: [ "QWinThumbnailToolBar", "private", "<QWinThumbnailToolBar>", "public" ] },
+    { symbol: [ "QWinThumbnailToolButton", "private", "<QWinThumbnailToolButton>", "public" ] },
+    { symbol: [ "QWindow", "private", "<QWindow>", "public" ] },
+    { symbol: [ "QWindowList", "private", "<QWindowList>", "public" ] },
+    { symbol: [ "QWindowStateChangeEvent", "private", "<QWindowStateChangeEvent>", "public" ] },
+    { symbol: [ "QWizard", "private", "<QWizard>", "public" ] },
+    { symbol: [ "QWizardPage", "private", "<QWizardPage>", "public" ] },
+    { symbol: [ "QWriteLocker", "private", "<QWriteLocker>", "public" ] },
+    { symbol: [ "QXcbWindowFunctions", "private", "<QXcbWindowFunctions>", "public" ] },
+    { symbol: [ "QXmlAttributes", "private", "<QXmlAttributes>", "public" ] },
+    { symbol: [ "QXmlContentHandler", "private", "<QXmlContentHandler>", "public" ] },
+    { symbol: [ "QXmlDTDHandler", "private", "<QXmlDTDHandler>", "public" ] },
+    { symbol: [ "QXmlDeclHandler", "private", "<QXmlDeclHandler>", "public" ] },
+    { symbol: [ "QXmlDefaultHandler", "private", "<QXmlDefaultHandler>", "public" ] },
+    { symbol: [ "QXmlEntityResolver", "private", "<QXmlEntityResolver>", "public" ] },
+    { symbol: [ "QXmlErrorHandler", "private", "<QXmlErrorHandler>", "public" ] },
+    { symbol: [ "QXmlFormatter", "private", "<QXmlFormatter>", "public" ] },
+    { symbol: [ "QXmlInputSource", "private", "<QXmlInputSource>", "public" ] },
+    { symbol: [ "QXmlItem", "private", "<QXmlItem>", "public" ] },
+    { symbol: [ "QXmlLexicalHandler", "private", "<QXmlLexicalHandler>", "public" ] },
+    { symbol: [ "QXmlLocator", "private", "<QXmlLocator>", "public" ] },
+    { symbol: [ "QXmlName", "private", "<QXmlName>", "public" ] },
+    { symbol: [ "QXmlNamePool", "private", "<QXmlNamePool>", "public" ] },
+    { symbol: [ "QXmlNamespaceSupport", "private", "<QXmlNamespaceSupport>", "public" ] },
+    { symbol: [ "QXmlNodeModelIndex", "private", "<QXmlNodeModelIndex>", "public" ] },
+    { symbol: [ "QXmlParseException", "private", "<QXmlParseException>", "public" ] },
+    { symbol: [ "QXmlQuery", "private", "<QXmlQuery>", "public" ] },
+    { symbol: [ "QXmlReader", "private", "<QXmlReader>", "public" ] },
+    { symbol: [ "QXmlResultItems", "private", "<QXmlResultItems>", "public" ] },
+    { symbol: [ "QXmlSchema", "private", "<QXmlSchema>", "public" ] },
+    { symbol: [ "QXmlSchemaValidator", "private", "<QXmlSchemaValidator>", "public" ] },
+    { symbol: [ "QXmlSerializer", "private", "<QXmlSerializer>", "public" ] },
+    { symbol: [ "QXmlSimpleReader", "private", "<QXmlSimpleReader>", "public" ] },
+    { symbol: [ "QXmlStreamAttribute", "private", "<QXmlStreamAttribute>", "public" ] },
+    { symbol: [ "QXmlStreamAttributes", "private", "<QXmlStreamAttributes>", "public" ] },
+    { symbol: [ "QXmlStreamEntityDeclaration", "private", "<QXmlStreamEntityDeclaration>", "public" ] },
+    { symbol: [ "QXmlStreamEntityDeclarations", "private", "<QXmlStreamEntityDeclarations>", "public" ] },
+    { symbol: [ "QXmlStreamEntityResolver", "private", "<QXmlStreamEntityResolver>", "public" ] },
+    { symbol: [ "QXmlStreamNamespaceDeclaration", "private", "<QXmlStreamNamespaceDeclaration>", "public" ] },
+    { symbol: [ "QXmlStreamNamespaceDeclarations", "private", "<QXmlStreamNamespaceDeclarations>", "public" ] },
+    { symbol: [ "QXmlStreamNotationDeclaration", "private", "<QXmlStreamNotationDeclaration>", "public" ] },
+    { symbol: [ "QXmlStreamNotationDeclarations", "private", "<QXmlStreamNotationDeclarations>", "public" ] },
+    { symbol: [ "QXmlStreamReader", "private", "<QXmlStreamReader>", "public" ] },
+    { symbol: [ "QXmlStreamStringRef", "private", "<QXmlStreamStringRef>", "public" ] },
+    { symbol: [ "QXmlStreamWriter", "private", "<QXmlStreamWriter>", "public" ] },
+    { symbol: [ "Q_IPV6ADDR", "private", "<Q_IPV6ADDR>", "public" ] },
+    { symbol: [ "Q_PID", "private", "<Q_PID>", "public" ] },
+    { symbol: [ "Qt", "private", "<Qt>", "public" ] },
+    { symbol: [ "QtAlgorithms", "private", "<QtAlgorithms>", "public" ] },
+    { symbol: [ "QtBluetooth", "private", "<QtBluetooth>", "public" ] },
+    { symbol: [ "QtBluetoothDepends", "private", "<QtBluetoothDepends>", "public" ] },
+    { symbol: [ "QtBluetoothVersion", "private", "<QtBluetoothVersion>", "public" ] },
+    { symbol: [ "QtCLucene", "private", "<QtCLucene>", "public" ] },
+    { symbol: [ "QtCLuceneDepends", "private", "<QtCLuceneDepends>", "public" ] },
+    { symbol: [ "QtCLuceneVersion", "private", "<QtCLuceneVersion>", "public" ] },
+    { symbol: [ "QtCleanUpFunction", "private", "<QtCleanUpFunction>", "public" ] },
+    { symbol: [ "QtConcurrent", "private", "<QtConcurrent>", "public" ] },
+    { symbol: [ "QtConcurrentDepends", "private", "<QtConcurrentDepends>", "public" ] },
+    { symbol: [ "QtConcurrentFilter", "private", "<QtConcurrentFilter>", "public" ] },
+    { symbol: [ "QtConcurrentMap", "private", "<QtConcurrentMap>", "public" ] },
+    { symbol: [ "QtConcurrentRun", "private", "<QtConcurrentRun>", "public" ] },
+    { symbol: [ "QtConcurrentVersion", "private", "<QtConcurrentVersion>", "public" ] },
+    { symbol: [ "QtConfig", "private", "<QtConfig>", "public" ] },
+    { symbol: [ "QtContainerFwd", "private", "<QtContainerFwd>", "public" ] },
+    { symbol: [ "QtCore", "private", "<QtCore>", "public" ] },
+    { symbol: [ "QtCoreDepends", "private", "<QtCoreDepends>", "public" ] },
+    { symbol: [ "QtCoreVersion", "private", "<QtCoreVersion>", "public" ] },
+    { symbol: [ "QtDBus", "private", "<QtDBus>", "public" ] },
+    { symbol: [ "QtDBusDepends", "private", "<QtDBusDepends>", "public" ] },
+    { symbol: [ "QtDBusVersion", "private", "<QtDBusVersion>", "public" ] },
+    { symbol: [ "QtDebug", "private", "<QtDebug>", "public" ] },
+    { symbol: [ "QtDeclarative", "private", "<QtDeclarative>", "public" ] },
+    { symbol: [ "QtDeclarativeDepends", "private", "<QtDeclarativeDepends>", "public" ] },
+    { symbol: [ "QtDeclarativeVersion", "private", "<QtDeclarativeVersion>", "public" ] },
+    { symbol: [ "QtDesigner", "private", "<QtDesigner>", "public" ] },
+    { symbol: [ "QtDesignerComponents", "private", "<QtDesignerComponents>", "public" ] },
+    { symbol: [ "QtDesignerComponentsDepends", "private", "<QtDesignerComponentsDepends>", "public" ] },
+    { symbol: [ "QtDesignerComponentsVersion", "private", "<QtDesignerComponentsVersion>", "public" ] },
+    { symbol: [ "QtDesignerDepends", "private", "<QtDesignerDepends>", "public" ] },
+    { symbol: [ "QtDesignerVersion", "private", "<QtDesignerVersion>", "public" ] },
+    { symbol: [ "QtEndian", "private", "<QtEndian>", "public" ] },
+    { symbol: [ "QtEvents", "private", "<QtEvents>", "public" ] },
+    { symbol: [ "QtGlobal", "private", "<QtGlobal>", "public" ] },
+    { symbol: [ "QtGui", "private", "<QtGui>", "public" ] },
+    { symbol: [ "QtGuiDepends", "private", "<QtGuiDepends>", "public" ] },
+    { symbol: [ "QtGuiVersion", "private", "<QtGuiVersion>", "public" ] },
+    { symbol: [ "QtHelp", "private", "<QtHelp>", "public" ] },
+    { symbol: [ "QtHelpDepends", "private", "<QtHelpDepends>", "public" ] },
+    { symbol: [ "QtHelpVersion", "private", "<QtHelpVersion>", "public" ] },
+    { symbol: [ "QtLocation", "private", "<QtLocation>", "public" ] },
+    { symbol: [ "QtLocationDepends", "private", "<QtLocationDepends>", "public" ] },
+    { symbol: [ "QtLocationVersion", "private", "<QtLocationVersion>", "public" ] },
+    { symbol: [ "QtMath", "private", "<QtMath>", "public" ] },
+    { symbol: [ "QtMessageHandler", "private", "<QtMessageHandler>", "public" ] },
+    { symbol: [ "QtMsgHandler", "private", "<QtMsgHandler>", "public" ] },
+    { symbol: [ "QtMultimedia", "private", "<QtMultimedia>", "public" ] },
+    { symbol: [ "QtMultimediaDepends", "private", "<QtMultimediaDepends>", "public" ] },
+    { symbol: [ "QtMultimediaQuick_p", "private", "<QtMultimediaQuick_p>", "public" ] },
+    { symbol: [ "QtMultimediaQuick_pDepends", "private", "<QtMultimediaQuick_pDepends>", "public" ] },
+    { symbol: [ "QtMultimediaQuick_pVersion", "private", "<QtMultimediaQuick_pVersion>", "public" ] },
+    { symbol: [ "QtMultimediaVersion", "private", "<QtMultimediaVersion>", "public" ] },
+    { symbol: [ "QtMultimediaWidgets", "private", "<QtMultimediaWidgets>", "public" ] },
+    { symbol: [ "QtMultimediaWidgetsDepends", "private", "<QtMultimediaWidgetsDepends>", "public" ] },
+    { symbol: [ "QtMultimediaWidgetsVersion", "private", "<QtMultimediaWidgetsVersion>", "public" ] },
+    { symbol: [ "QtNetwork", "private", "<QtNetwork>", "public" ] },
+    { symbol: [ "QtNetworkDepends", "private", "<QtNetworkDepends>", "public" ] },
+    { symbol: [ "QtNetworkVersion", "private", "<QtNetworkVersion>", "public" ] },
+    { symbol: [ "QtNfc", "private", "<QtNfc>", "public" ] },
+    { symbol: [ "QtNfcDepends", "private", "<QtNfcDepends>", "public" ] },
+    { symbol: [ "QtNfcVersion", "private", "<QtNfcVersion>", "public" ] },
+    { symbol: [ "QtNumeric", "private", "<QtNumeric>", "public" ] },
+    { symbol: [ "QtOpenGL", "private", "<QtOpenGL>", "public" ] },
+    { symbol: [ "QtOpenGLDepends", "private", "<QtOpenGLDepends>", "public" ] },
+    { symbol: [ "QtOpenGLExtensions", "private", "<QtOpenGLExtensions>", "public" ] },
+    { symbol: [ "QtOpenGLExtensionsDepends", "private", "<QtOpenGLExtensionsDepends>", "public" ] },
+    { symbol: [ "QtOpenGLExtensionsVersion", "private", "<QtOpenGLExtensionsVersion>", "public" ] },
+    { symbol: [ "QtOpenGLVersion", "private", "<QtOpenGLVersion>", "public" ] },
+    { symbol: [ "QtPlatformHeaders", "private", "<QtPlatformHeaders>", "public" ] },
+    { symbol: [ "QtPlatformHeadersDepends", "private", "<QtPlatformHeadersDepends>", "public" ] },
+    { symbol: [ "QtPlatformHeadersVersion", "private", "<QtPlatformHeadersVersion>", "public" ] },
+    { symbol: [ "QtPlatformSupport", "private", "<QtPlatformSupport>", "public" ] },
+    { symbol: [ "QtPlatformSupportDepends", "private", "<QtPlatformSupportDepends>", "public" ] },
+    { symbol: [ "QtPlatformSupportVersion", "private", "<QtPlatformSupportVersion>", "public" ] },
+    { symbol: [ "QtPlugin", "private", "<QtPlugin>", "public" ] },
+    { symbol: [ "QtPluginInstanceFunction", "private", "<QtPluginInstanceFunction>", "public" ] },
+    { symbol: [ "QtPluginMetaDataFunction", "private", "<QtPluginMetaDataFunction>", "public" ] },
+    { symbol: [ "QtPositioning", "private", "<QtPositioning>", "public" ] },
+    { symbol: [ "QtPositioningDepends", "private", "<QtPositioningDepends>", "public" ] },
+    { symbol: [ "QtPositioningVersion", "private", "<QtPositioningVersion>", "public" ] },
+    { symbol: [ "QtPrintSupport", "private", "<QtPrintSupport>", "public" ] },
+    { symbol: [ "QtPrintSupportDepends", "private", "<QtPrintSupportDepends>", "public" ] },
+    { symbol: [ "QtPrintSupportVersion", "private", "<QtPrintSupportVersion>", "public" ] },
+    { symbol: [ "QtQml", "private", "<QtQml>", "public" ] },
+    { symbol: [ "QtQmlDepends", "private", "<QtQmlDepends>", "public" ] },
+    { symbol: [ "QtQmlVersion", "private", "<QtQmlVersion>", "public" ] },
+    { symbol: [ "QtQuick", "private", "<QtQuick>", "public" ] },
+    { symbol: [ "QtQuickDepends", "private", "<QtQuickDepends>", "public" ] },
+    { symbol: [ "QtQuickParticles", "private", "<QtQuickParticles>", "public" ] },
+    { symbol: [ "QtQuickParticlesDepends", "private", "<QtQuickParticlesDepends>", "public" ] },
+    { symbol: [ "QtQuickParticlesVersion", "private", "<QtQuickParticlesVersion>", "public" ] },
+    { symbol: [ "QtQuickTest", "private", "<QtQuickTest>", "public" ] },
+    { symbol: [ "QtQuickTestDepends", "private", "<QtQuickTestDepends>", "public" ] },
+    { symbol: [ "QtQuickTestVersion", "private", "<QtQuickTestVersion>", "public" ] },
+    { symbol: [ "QtQuickVersion", "private", "<QtQuickVersion>", "public" ] },
+    { symbol: [ "QtQuickWidgets", "private", "<QtQuickWidgets>", "public" ] },
+    { symbol: [ "QtQuickWidgetsDepends", "private", "<QtQuickWidgetsDepends>", "public" ] },
+    { symbol: [ "QtQuickWidgetsVersion", "private", "<QtQuickWidgetsVersion>", "public" ] },
+    { symbol: [ "QtScript", "private", "<QtScript>", "public" ] },
+    { symbol: [ "QtScriptDepends", "private", "<QtScriptDepends>", "public" ] },
+    { symbol: [ "QtScriptTools", "private", "<QtScriptTools>", "public" ] },
+    { symbol: [ "QtScriptToolsDepends", "private", "<QtScriptToolsDepends>", "public" ] },
+    { symbol: [ "QtScriptToolsVersion", "private", "<QtScriptToolsVersion>", "public" ] },
+    { symbol: [ "QtScriptVersion", "private", "<QtScriptVersion>", "public" ] },
+    { symbol: [ "QtSensors", "private", "<QtSensors>", "public" ] },
+    { symbol: [ "QtSensorsDepends", "private", "<QtSensorsDepends>", "public" ] },
+    { symbol: [ "QtSensorsVersion", "private", "<QtSensorsVersion>", "public" ] },
+    { symbol: [ "QtSerialPort", "private", "<QtSerialPort>", "public" ] },
+    { symbol: [ "QtSerialPortDepends", "private", "<QtSerialPortDepends>", "public" ] },
+    { symbol: [ "QtSerialPortVersion", "private", "<QtSerialPortVersion>", "public" ] },
+    { symbol: [ "QtSql", "private", "<QtSql>", "public" ] },
+    { symbol: [ "QtSqlDepends", "private", "<QtSqlDepends>", "public" ] },
+    { symbol: [ "QtSqlVersion", "private", "<QtSqlVersion>", "public" ] },
+    { symbol: [ "QtSvg", "private", "<QtSvg>", "public" ] },
+    { symbol: [ "QtSvgDepends", "private", "<QtSvgDepends>", "public" ] },
+    { symbol: [ "QtSvgVersion", "private", "<QtSvgVersion>", "public" ] },
+    { symbol: [ "QtTest", "private", "<QtTest>", "public" ] },
+    { symbol: [ "QtTestDepends", "private", "<QtTestDepends>", "public" ] },
+    { symbol: [ "QtTestGui", "private", "<QtTestGui>", "public" ] },
+    { symbol: [ "QtTestVersion", "private", "<QtTestVersion>", "public" ] },
+    { symbol: [ "QtTestWidgets", "private", "<QtTestWidgets>", "public" ] },
+    { symbol: [ "QtUiTools", "private", "<QtUiTools>", "public" ] },
+    { symbol: [ "QtUiToolsDepends", "private", "<QtUiToolsDepends>", "public" ] },
+    { symbol: [ "QtUiToolsVersion", "private", "<QtUiToolsVersion>", "public" ] },
+    { symbol: [ "QtWebChannel", "private", "<QtWebChannel>", "public" ] },
+    { symbol: [ "QtWebChannelDepends", "private", "<QtWebChannelDepends>", "public" ] },
+    { symbol: [ "QtWebChannelVersion", "private", "<QtWebChannelVersion>", "public" ] },
+    { symbol: [ "QtWebKit", "private", "<QtWebKit>", "public" ] },
+    { symbol: [ "QtWebKitDepends", "private", "<QtWebKitDepends>", "public" ] },
+    { symbol: [ "QtWebKitVersion", "private", "<QtWebKitVersion>", "public" ] },
+    { symbol: [ "QtWebKitWidgets", "private", "<QtWebKitWidgets>", "public" ] },
+    { symbol: [ "QtWebKitWidgetsDepends", "private", "<QtWebKitWidgetsDepends>", "public" ] },
+    { symbol: [ "QtWebKitWidgetsVersion", "private", "<QtWebKitWidgetsVersion>", "public" ] },
+    { symbol: [ "QtWebSockets", "private", "<QtWebSockets>", "public" ] },
+    { symbol: [ "QtWebSocketsDepends", "private", "<QtWebSocketsDepends>", "public" ] },
+    { symbol: [ "QtWebSocketsVersion", "private", "<QtWebSocketsVersion>", "public" ] },
+    { symbol: [ "QtWidgets", "private", "<QtWidgets>", "public" ] },
+    { symbol: [ "QtWidgetsDepends", "private", "<QtWidgetsDepends>", "public" ] },
+    { symbol: [ "QtWidgetsVersion", "private", "<QtWidgetsVersion>", "public" ] },
+    { symbol: [ "QtWin", "private", "<QtWin>", "public" ] },
+    { symbol: [ "QtWinExtras", "private", "<QtWinExtras>", "public" ] },
+    { symbol: [ "QtWinExtrasDepends", "private", "<QtWinExtrasDepends>", "public" ] },
+    { symbol: [ "QtWinExtrasVersion", "private", "<QtWinExtrasVersion>", "public" ] },
+    { symbol: [ "QtXml", "private", "<QtXml>", "public" ] },
+    { symbol: [ "QtXmlDepends", "private", "<QtXmlDepends>", "public" ] },
+    { symbol: [ "QtXmlPatterns", "private", "<QtXmlPatterns>", "public" ] },
+    { symbol: [ "QtXmlPatternsDepends", "private", "<QtXmlPatternsDepends>", "public" ] },
+    { symbol: [ "QtXmlPatternsVersion", "private", "<QtXmlPatternsVersion>", "public" ] },
+    { symbol: [ "QtXmlVersion", "private", "<QtXmlVersion>", "public" ] },
+
+## other things not picked up by the above
+    #{ symbol: [ "qobject_cast", "private", "<QObject>", "public" ] },
+    #{ symbol: [ "qApp", "private", "<QApplication>", "public" ] },
+    #{ symbol: [ "qHash", "private", "<QHash>", "public" ] },
+
+# This is necessary because QList::toSet ends up in QSet which is wrong. See note
+# at top as to why this shouldn't be necessary
+
+    { symbol: [ "QList::toSet", "private", "<QList>", "public" ] },
+
+# Even if IWYU recognised A::B as coming from a.h, we'd still need a lot of these for
+# free operators
+    
+# Generated with
+#    perl -le "use File::Find;use File::Basename; sub wanted { $x = lc $_. '.h'; print '    { include: [ -@\-('.basename($File::Find::dir).'/)?'.$x.'\--, -private-, -<'.$_.'>-, -public- ] },' if -e $x } find(\&wanted, '.')"
+# on windows
+
+    { include: [ "@\"(ActiveQt/)?activeqtversion\\.h\"", "private", "<ActiveQtVersion>", "public" ] },
+    { include: [ "@\"(ActiveQt/)?qaxaggregated\\.h\"", "private", "<QAxAggregated>", "public" ] },
+    { include: [ "@\"(ActiveQt/)?qaxbase\\.h\"", "private", "<QAxBase>", "public" ] },
+    { include: [ "@\"(ActiveQt/)?qaxbindable\\.h\"", "private", "<QAxBindable>", "public" ] },
+    { include: [ "@\"(ActiveQt/)?qaxfactory\\.h\"", "private", "<QAxFactory>", "public" ] },
+    { include: [ "@\"(ActiveQt/)?qaxobject\\.h\"", "private", "<QAxObject>", "public" ] },
+    { include: [ "@\"(ActiveQt/)?qaxscript\\.h\"", "private", "<QAxScript>", "public" ] },
+    { include: [ "@\"(ActiveQt/)?qaxselect\\.h\"", "private", "<QAxSelect>", "public" ] },
+    { include: [ "@\"(ActiveQt/)?qaxwidget\\.h\"", "private", "<QAxWidget>", "public" ] },
+    { include: [ "@\"(Enginio/)?enginio\\.h\"", "private", "<Enginio>", "public" ] },
+    { include: [ "@\"(Enginio/)?enginioversion\\.h\"", "private", "<EnginioVersion>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qbluetoothaddress\\.h\"", "private", "<QBluetoothAddress>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qbluetoothdevicediscoveryagent\\.h\"", "private", "<QBluetoothDeviceDiscoveryAgent>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qbluetoothdeviceinfo\\.h\"", "private", "<QBluetoothDeviceInfo>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qbluetoothhostinfo\\.h\"", "private", "<QBluetoothHostInfo>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qbluetoothlocaldevice\\.h\"", "private", "<QBluetoothLocalDevice>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qbluetoothserver\\.h\"", "private", "<QBluetoothServer>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qbluetoothservicediscoveryagent\\.h\"", "private", "<QBluetoothServiceDiscoveryAgent>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qbluetoothserviceinfo\\.h\"", "private", "<QBluetoothServiceInfo>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qbluetoothsocket\\.h\"", "private", "<QBluetoothSocket>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qbluetoothtransfermanager\\.h\"", "private", "<QBluetoothTransferManager>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qbluetoothtransferreply\\.h\"", "private", "<QBluetoothTransferReply>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qbluetoothtransferrequest\\.h\"", "private", "<QBluetoothTransferRequest>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qbluetoothuuid\\.h\"", "private", "<QBluetoothUuid>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qlowenergycharacteristic\\.h\"", "private", "<QLowEnergyCharacteristic>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qlowenergycontroller\\.h\"", "private", "<QLowEnergyController>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qlowenergydescriptor\\.h\"", "private", "<QLowEnergyDescriptor>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qlowenergyservice\\.h\"", "private", "<QLowEnergyService>", "public" ] },
+    { include: [ "@\"(QtBluetooth/)?qtbluetoothversion\\.h\"", "private", "<QtBluetoothVersion>", "public" ] },
+    { include: [ "@\"(QtCLucene/)?qtcluceneversion\\.h\"", "private", "<QtCLuceneVersion>", "public" ] },
+    { include: [ "@\"(QtConcurrent/)?qtconcurrentfilter\\.h\"", "private", "<QtConcurrentFilter>", "public" ] },
+    { include: [ "@\"(QtConcurrent/)?qtconcurrentmap\\.h\"", "private", "<QtConcurrentMap>", "public" ] },
+    { include: [ "@\"(QtConcurrent/)?qtconcurrentrun\\.h\"", "private", "<QtConcurrentRun>", "public" ] },
+    { include: [ "@\"(QtConcurrent/)?qtconcurrentversion\\.h\"", "private", "<QtConcurrentVersion>", "public" ] },
+    { include: [ "@\"(QtCore/)?qabstractanimation\\.h\"", "private", "<QAbstractAnimation>", "public" ] },
+    { include: [ "@\"(QtCore/)?qabstracteventdispatcher\\.h\"", "private", "<QAbstractEventDispatcher>", "public" ] },
+    { include: [ "@\"(QtCore/)?qabstractitemmodel\\.h\"", "private", "<QAbstractItemModel>", "public" ] },
+    { include: [ "@\"(QtCore/)?qabstractnativeeventfilter\\.h\"", "private", "<QAbstractNativeEventFilter>", "public" ] },
+    { include: [ "@\"(QtCore/)?qabstractproxymodel\\.h\"", "private", "<QAbstractProxyModel>", "public" ] },
+    { include: [ "@\"(QtCore/)?qabstractstate\\.h\"", "private", "<QAbstractState>", "public" ] },
+    { include: [ "@\"(QtCore/)?qabstracttransition\\.h\"", "private", "<QAbstractTransition>", "public" ] },
+    { include: [ "@\"(QtCore/)?qanimationgroup\\.h\"", "private", "<QAnimationGroup>", "public" ] },
+    { include: [ "@\"(QtCore/)?qarraydata\\.h\"", "private", "<QArrayData>", "public" ] },
+    { include: [ "@\"(QtCore/)?qarraydatapointer\\.h\"", "private", "<QArrayDataPointer>", "public" ] },
+    { include: [ "@\"(QtCore/)?qbasictimer\\.h\"", "private", "<QBasicTimer>", "public" ] },
+    { include: [ "@\"(QtCore/)?qbitarray\\.h\"", "private", "<QBitArray>", "public" ] },
+    { include: [ "@\"(QtCore/)?qbuffer\\.h\"", "private", "<QBuffer>", "public" ] },
+    { include: [ "@\"(QtCore/)?qbytearray\\.h\"", "private", "<QByteArray>", "public" ] },
+    { include: [ "@\"(QtCore/)?qbytearraylist\\.h\"", "private", "<QByteArrayList>", "public" ] },
+    { include: [ "@\"(QtCore/)?qbytearraymatcher\\.h\"", "private", "<QByteArrayMatcher>", "public" ] },
+    { include: [ "@\"(QtCore/)?qcache\\.h\"", "private", "<QCache>", "public" ] },
+    { include: [ "@\"(QtCore/)?qchar\\.h\"", "private", "<QChar>", "public" ] },
+    { include: [ "@\"(QtCore/)?qcollator\\.h\"", "private", "<QCollator>", "public" ] },
+    { include: [ "@\"(QtCore/)?qcommandlineoption\\.h\"", "private", "<QCommandLineOption>", "public" ] },
+    { include: [ "@\"(QtCore/)?qcommandlineparser\\.h\"", "private", "<QCommandLineParser>", "public" ] },
+    { include: [ "@\"(QtCore/)?qcontiguouscache\\.h\"", "private", "<QContiguousCache>", "public" ] },
+    { include: [ "@\"(QtCore/)?qcoreapplication\\.h\"", "private", "<QCoreApplication>", "public" ] },
+    { include: [ "@\"(QtCore/)?qcryptographichash\\.h\"", "private", "<QCryptographicHash>", "public" ] },
+    { include: [ "@\"(QtCore/)?qdatastream\\.h\"", "private", "<QDataStream>", "public" ] },
+    { include: [ "@\"(QtCore/)?qdatetime\\.h\"", "private", "<QDateTime>", "public" ] },
+    { include: [ "@\"(QtCore/)?qdebug\\.h\"", "private", "<QDebug>", "public" ] },
+    { include: [ "@\"(QtCore/)?qdir\\.h\"", "private", "<QDir>", "public" ] },
+    { include: [ "@\"(QtCore/)?qdiriterator\\.h\"", "private", "<QDirIterator>", "public" ] },
+    { include: [ "@\"(QtCore/)?qeasingcurve\\.h\"", "private", "<QEasingCurve>", "public" ] },
+    { include: [ "@\"(QtCore/)?qelapsedtimer\\.h\"", "private", "<QElapsedTimer>", "public" ] },
+    { include: [ "@\"(QtCore/)?qeventloop\\.h\"", "private", "<QEventLoop>", "public" ] },
+    { include: [ "@\"(QtCore/)?qeventtransition\\.h\"", "private", "<QEventTransition>", "public" ] },
+    { include: [ "@\"(QtCore/)?qexception\\.h\"", "private", "<QException>", "public" ] },
+    { include: [ "@\"(QtCore/)?qfactoryinterface\\.h\"", "private", "<QFactoryInterface>", "public" ] },
+    { include: [ "@\"(QtCore/)?qfile\\.h\"", "private", "<QFile>", "public" ] },
+    { include: [ "@\"(QtCore/)?qfiledevice\\.h\"", "private", "<QFileDevice>", "public" ] },
+    { include: [ "@\"(QtCore/)?qfileinfo\\.h\"", "private", "<QFileInfo>", "public" ] },
+    { include: [ "@\"(QtCore/)?qfileselector\\.h\"", "private", "<QFileSelector>", "public" ] },
+    { include: [ "@\"(QtCore/)?qfilesystemwatcher\\.h\"", "private", "<QFileSystemWatcher>", "public" ] },
+    { include: [ "@\"(QtCore/)?qfinalstate\\.h\"", "private", "<QFinalState>", "public" ] },
+    { include: [ "@\"(QtCore/)?qflags\\.h\"", "private", "<QFlags>", "public" ] },
+    { include: [ "@\"(QtCore/)?qfuture\\.h\"", "private", "<QFuture>", "public" ] },
+    { include: [ "@\"(QtCore/)?qfutureinterface\\.h\"", "private", "<QFutureInterface>", "public" ] },
+    { include: [ "@\"(QtCore/)?qfuturesynchronizer\\.h\"", "private", "<QFutureSynchronizer>", "public" ] },
+    { include: [ "@\"(QtCore/)?qfuturewatcher\\.h\"", "private", "<QFutureWatcher>", "public" ] },
+    { include: [ "@\"(QtCore/)?qglobalstatic\\.h\"", "private", "<QGlobalStatic>", "public" ] },
+    { include: [ "@\"(QtCore/)?qhash\\.h\"", "private", "<QHash>", "public" ] },
+    { include: [ "@\"(QtCore/)?qhistorystate\\.h\"", "private", "<QHistoryState>", "public" ] },
+    { include: [ "@\"(QtCore/)?qidentityproxymodel\\.h\"", "private", "<QIdentityProxyModel>", "public" ] },
+    { include: [ "@\"(QtCore/)?qiodevice\\.h\"", "private", "<QIODevice>", "public" ] },
+    { include: [ "@\"(QtCore/)?qitemselectionmodel\\.h\"", "private", "<QItemSelectionModel>", "public" ] },
+    { include: [ "@\"(QtCore/)?qjsonarray\\.h\"", "private", "<QJsonArray>", "public" ] },
+    { include: [ "@\"(QtCore/)?qjsondocument\\.h\"", "private", "<QJsonDocument>", "public" ] },
+    { include: [ "@\"(QtCore/)?qjsonobject\\.h\"", "private", "<QJsonObject>", "public" ] },
+    { include: [ "@\"(QtCore/)?qjsonvalue\\.h\"", "private", "<QJsonValue>", "public" ] },
+    { include: [ "@\"(QtCore/)?qlibrary\\.h\"", "private", "<QLibrary>", "public" ] },
+    { include: [ "@\"(QtCore/)?qlibraryinfo\\.h\"", "private", "<QLibraryInfo>", "public" ] },
+    { include: [ "@\"(QtCore/)?qline\\.h\"", "private", "<QLine>", "public" ] },
+    { include: [ "@\"(QtCore/)?qlinkedlist\\.h\"", "private", "<QLinkedList>", "public" ] },
+    { include: [ "@\"(QtCore/)?qlist\\.h\"", "private", "<QList>", "public" ] },
+    { include: [ "@\"(QtCore/)?qlocale\\.h\"", "private", "<QLocale>", "public" ] },
+    { include: [ "@\"(QtCore/)?qlockfile\\.h\"", "private", "<QLockFile>", "public" ] },
+    { include: [ "@\"(QtCore/)?qloggingcategory\\.h\"", "private", "<QLoggingCategory>", "public" ] },
+    { include: [ "@\"(QtCore/)?qmap\\.h\"", "private", "<QMap>", "public" ] },
+    { include: [ "@\"(QtCore/)?qmargins\\.h\"", "private", "<QMargins>", "public" ] },
+    { include: [ "@\"(QtCore/)?qmessageauthenticationcode\\.h\"", "private", "<QMessageAuthenticationCode>", "public" ] },
+    { include: [ "@\"(QtCore/)?qmetaobject\\.h\"", "private", "<QMetaObject>", "public" ] },
+    { include: [ "@\"(QtCore/)?qmetatype\\.h\"", "private", "<QMetaType>", "public" ] },
+    { include: [ "@\"(QtCore/)?qmimedata\\.h\"", "private", "<QMimeData>", "public" ] },
+    { include: [ "@\"(QtCore/)?qmimedatabase\\.h\"", "private", "<QMimeDatabase>", "public" ] },
+    { include: [ "@\"(QtCore/)?qmimetype\\.h\"", "private", "<QMimeType>", "public" ] },
+    { include: [ "@\"(QtCore/)?qmutex\\.h\"", "private", "<QMutex>", "public" ] },
+    { include: [ "@\"(QtCore/)?qobject\\.h\"", "private", "<QObject>", "public" ] },
+    { include: [ "@\"(QtCore/)?qobjectcleanuphandler\\.h\"", "private", "<QObjectCleanupHandler>", "public" ] },
+    { include: [ "@\"(QtCore/)?qpair\\.h\"", "private", "<QPair>", "public" ] },
+    { include: [ "@\"(QtCore/)?qparallelanimationgroup\\.h\"", "private", "<QParallelAnimationGroup>", "public" ] },
+    { include: [ "@\"(QtCore/)?qpauseanimation\\.h\"", "private", "<QPauseAnimation>", "public" ] },
+    { include: [ "@\"(QtCore/)?qpluginloader\\.h\"", "private", "<QPluginLoader>", "public" ] },
+    { include: [ "@\"(QtCore/)?qpoint\\.h\"", "private", "<QPoint>", "public" ] },
+    { include: [ "@\"(QtCore/)?qpointer\\.h\"", "private", "<QPointer>", "public" ] },
+    { include: [ "@\"(QtCore/)?qprocess\\.h\"", "private", "<QProcess>", "public" ] },
+    { include: [ "@\"(QtCore/)?qpropertyanimation\\.h\"", "private", "<QPropertyAnimation>", "public" ] },
+    { include: [ "@\"(QtCore/)?qqueue\\.h\"", "private", "<QQueue>", "public" ] },
+    { include: [ "@\"(QtCore/)?qreadwritelock\\.h\"", "private", "<QReadWriteLock>", "public" ] },
+    { include: [ "@\"(QtCore/)?qrect\\.h\"", "private", "<QRect>", "public" ] },
+    { include: [ "@\"(QtCore/)?qregexp\\.h\"", "private", "<QRegExp>", "public" ] },
+    { include: [ "@\"(QtCore/)?qregularexpression\\.h\"", "private", "<QRegularExpression>", "public" ] },
+    { include: [ "@\"(QtCore/)?qresource\\.h\"", "private", "<QResource>", "public" ] },
+    { include: [ "@\"(QtCore/)?qrunnable\\.h\"", "private", "<QRunnable>", "public" ] },
+    { include: [ "@\"(QtCore/)?qsavefile\\.h\"", "private", "<QSaveFile>", "public" ] },
+    { include: [ "@\"(QtCore/)?qscopedpointer\\.h\"", "private", "<QScopedPointer>", "public" ] },
+    { include: [ "@\"(QtCore/)?qscopedvaluerollback\\.h\"", "private", "<QScopedValueRollback>", "public" ] },
+    { include: [ "@\"(QtCore/)?qsemaphore\\.h\"", "private", "<QSemaphore>", "public" ] },
+    { include: [ "@\"(QtCore/)?qsequentialanimationgroup\\.h\"", "private", "<QSequentialAnimationGroup>", "public" ] },
+    { include: [ "@\"(QtCore/)?qset\\.h\"", "private", "<QSet>", "public" ] },
+    { include: [ "@\"(QtCore/)?qsettings\\.h\"", "private", "<QSettings>", "public" ] },
+    { include: [ "@\"(QtCore/)?qshareddata\\.h\"", "private", "<QSharedData>", "public" ] },
+    { include: [ "@\"(QtCore/)?qsharedmemory\\.h\"", "private", "<QSharedMemory>", "public" ] },
+    { include: [ "@\"(QtCore/)?qsharedpointer\\.h\"", "private", "<QSharedPointer>", "public" ] },
+    { include: [ "@\"(QtCore/)?qsignalmapper\\.h\"", "private", "<QSignalMapper>", "public" ] },
+    { include: [ "@\"(QtCore/)?qsignaltransition\\.h\"", "private", "<QSignalTransition>", "public" ] },
+    { include: [ "@\"(QtCore/)?qsize\\.h\"", "private", "<QSize>", "public" ] },
+    { include: [ "@\"(QtCore/)?qsocketnotifier\\.h\"", "private", "<QSocketNotifier>", "public" ] },
+    { include: [ "@\"(QtCore/)?qsortfilterproxymodel\\.h\"", "private", "<QSortFilterProxyModel>", "public" ] },
+    { include: [ "@\"(QtCore/)?qstack\\.h\"", "private", "<QStack>", "public" ] },
+    { include: [ "@\"(QtCore/)?qstandardpaths\\.h\"", "private", "<QStandardPaths>", "public" ] },
+    { include: [ "@\"(QtCore/)?qstate\\.h\"", "private", "<QState>", "public" ] },
+    { include: [ "@\"(QtCore/)?qstatemachine\\.h\"", "private", "<QStateMachine>", "public" ] },
+    { include: [ "@\"(QtCore/)?qstorageinfo\\.h\"", "private", "<QStorageInfo>", "public" ] },
+    { include: [ "@\"(QtCore/)?qstring\\.h\"", "private", "<QString>", "public" ] },
+    { include: [ "@\"(QtCore/)?qstringbuilder\\.h\"", "private", "<QStringBuilder>", "public" ] },
+    { include: [ "@\"(QtCore/)?qstringlist\\.h\"", "private", "<QStringList>", "public" ] },
+    { include: [ "@\"(QtCore/)?qstringlistmodel\\.h\"", "private", "<QStringListModel>", "public" ] },
+    { include: [ "@\"(QtCore/)?qstringmatcher\\.h\"", "private", "<QStringMatcher>", "public" ] },
+    { include: [ "@\"(QtCore/)?qsysinfo\\.h\"", "private", "<QSysInfo>", "public" ] },
+    { include: [ "@\"(QtCore/)?qsystemsemaphore\\.h\"", "private", "<QSystemSemaphore>", "public" ] },
+    { include: [ "@\"(QtCore/)?qtcoreversion\\.h\"", "private", "<QtCoreVersion>", "public" ] },
+    { include: [ "@\"(QtCore/)?qtemporarydir\\.h\"", "private", "<QTemporaryDir>", "public" ] },
+    { include: [ "@\"(QtCore/)?qtemporaryfile\\.h\"", "private", "<QTemporaryFile>", "public" ] },
+    { include: [ "@\"(QtCore/)?qtextboundaryfinder\\.h\"", "private", "<QTextBoundaryFinder>", "public" ] },
+    { include: [ "@\"(QtCore/)?qtextcodec\\.h\"", "private", "<QTextCodec>", "public" ] },
+    { include: [ "@\"(QtCore/)?qtextstream\\.h\"", "private", "<QTextStream>", "public" ] },
+    { include: [ "@\"(QtCore/)?qthread\\.h\"", "private", "<QThread>", "public" ] },
+    { include: [ "@\"(QtCore/)?qthreadpool\\.h\"", "private", "<QThreadPool>", "public" ] },
+    { include: [ "@\"(QtCore/)?qthreadstorage\\.h\"", "private", "<QThreadStorage>", "public" ] },
+    { include: [ "@\"(QtCore/)?qtimeline\\.h\"", "private", "<QTimeLine>", "public" ] },
+    { include: [ "@\"(QtCore/)?qtimer\\.h\"", "private", "<QTimer>", "public" ] },
+    { include: [ "@\"(QtCore/)?qtimezone\\.h\"", "private", "<QTimeZone>", "public" ] },
+    { include: [ "@\"(QtCore/)?qtranslator\\.h\"", "private", "<QTranslator>", "public" ] },
+    { include: [ "@\"(QtCore/)?qtypeinfo\\.h\"", "private", "<QTypeInfo>", "public" ] },
+    { include: [ "@\"(QtCore/)?qurl\\.h\"", "private", "<QUrl>", "public" ] },
+    { include: [ "@\"(QtCore/)?qurlquery\\.h\"", "private", "<QUrlQuery>", "public" ] },
+    { include: [ "@\"(QtCore/)?quuid\\.h\"", "private", "<QUuid>", "public" ] },
+    { include: [ "@\"(QtCore/)?qvariant\\.h\"", "private", "<QVariant>", "public" ] },
+    { include: [ "@\"(QtCore/)?qvariantanimation\\.h\"", "private", "<QVariantAnimation>", "public" ] },
+    { include: [ "@\"(QtCore/)?qvarlengtharray\\.h\"", "private", "<QVarLengthArray>", "public" ] },
+    { include: [ "@\"(QtCore/)?qvector\\.h\"", "private", "<QVector>", "public" ] },
+    { include: [ "@\"(QtCore/)?qwaitcondition\\.h\"", "private", "<QWaitCondition>", "public" ] },
+    { include: [ "@\"(QtCore/)?qwineventnotifier\\.h\"", "private", "<QWinEventNotifier>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbusabstractadaptor\\.h\"", "private", "<QDBusAbstractAdaptor>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbusabstractinterface\\.h\"", "private", "<QDBusAbstractInterface>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbusargument\\.h\"", "private", "<QDBusArgument>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbusconnection\\.h\"", "private", "<QDBusConnection>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbusconnectioninterface\\.h\"", "private", "<QDBusConnectionInterface>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbuscontext\\.h\"", "private", "<QDBusContext>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbuserror\\.h\"", "private", "<QDBusError>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbusinterface\\.h\"", "private", "<QDBusInterface>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbusmessage\\.h\"", "private", "<QDBusMessage>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbusmetatype\\.h\"", "private", "<QDBusMetaType>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbuspendingcall\\.h\"", "private", "<QDBusPendingCall>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbuspendingreply\\.h\"", "private", "<QDBusPendingReply>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbusreply\\.h\"", "private", "<QDBusReply>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbusserver\\.h\"", "private", "<QDBusServer>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbusservicewatcher\\.h\"", "private", "<QDBusServiceWatcher>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbusunixfiledescriptor\\.h\"", "private", "<QDBusUnixFileDescriptor>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qdbusvirtualobject\\.h\"", "private", "<QDBusVirtualObject>", "public" ] },
+    { include: [ "@\"(QtDBus/)?qtdbusversion\\.h\"", "private", "<QtDBusVersion>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativecomponent\\.h\"", "private", "<QDeclarativeComponent>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativecontext\\.h\"", "private", "<QDeclarativeContext>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativeengine\\.h\"", "private", "<QDeclarativeEngine>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativeerror\\.h\"", "private", "<QDeclarativeError>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativeexpression\\.h\"", "private", "<QDeclarativeExpression>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativeextensioninterface\\.h\"", "private", "<QDeclarativeExtensionInterface>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativeextensionplugin\\.h\"", "private", "<QDeclarativeExtensionPlugin>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativeimageprovider\\.h\"", "private", "<QDeclarativeImageProvider>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativeinfo\\.h\"", "private", "<QDeclarativeInfo>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativeitem\\.h\"", "private", "<QDeclarativeItem>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativenetworkaccessmanagerfactory\\.h\"", "private", "<QDeclarativeNetworkAccessManagerFactory>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativeparserstatus\\.h\"", "private", "<QDeclarativeParserStatus>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativeproperty\\.h\"", "private", "<QDeclarativeProperty>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativepropertymap\\.h\"", "private", "<QDeclarativePropertyMap>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativepropertyvalueinterceptor\\.h\"", "private", "<QDeclarativePropertyValueInterceptor>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativepropertyvaluesource\\.h\"", "private", "<QDeclarativePropertyValueSource>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativescriptstring\\.h\"", "private", "<QDeclarativeScriptString>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qdeclarativeview\\.h\"", "private", "<QDeclarativeView>", "public" ] },
+    { include: [ "@\"(QtDeclarative/)?qtdeclarativeversion\\.h\"", "private", "<QtDeclarativeVersion>", "public" ] },
+    { include: [ "@\"(QtDesigner/)?qdesignerexportwidget\\.h\"", "private", "<QDesignerExportWidget>", "public" ] },
+    { include: [ "@\"(QtDesigner/)?qextensionmanager\\.h\"", "private", "<QExtensionManager>", "public" ] },
+    { include: [ "@\"(QtDesigner/)?qtdesignerversion\\.h\"", "private", "<QtDesignerVersion>", "public" ] },
+    { include: [ "@\"(QtDesignerComponents/)?qtdesignercomponentsversion\\.h\"", "private", "<QtDesignerComponentsVersion>", "public" ] },
+    { include: [ "@\"(QtGui/)?qabstracttextdocumentlayout\\.h\"", "private", "<QAbstractTextDocumentLayout>", "public" ] },
+    { include: [ "@\"(QtGui/)?qaccessible\\.h\"", "private", "<QAccessible>", "public" ] },
+    { include: [ "@\"(QtGui/)?qaccessiblebridge\\.h\"", "private", "<QAccessibleBridge>", "public" ] },
+    { include: [ "@\"(QtGui/)?qaccessibleobject\\.h\"", "private", "<QAccessibleObject>", "public" ] },
+    { include: [ "@\"(QtGui/)?qaccessibleplugin\\.h\"", "private", "<QAccessiblePlugin>", "public" ] },
+    { include: [ "@\"(QtGui/)?qbackingstore\\.h\"", "private", "<QBackingStore>", "public" ] },
+    { include: [ "@\"(QtGui/)?qbitmap\\.h\"", "private", "<QBitmap>", "public" ] },
+    { include: [ "@\"(QtGui/)?qbrush\\.h\"", "private", "<QBrush>", "public" ] },
+    { include: [ "@\"(QtGui/)?qclipboard\\.h\"", "private", "<QClipboard>", "public" ] },
+    { include: [ "@\"(QtGui/)?qcolor\\.h\"", "private", "<QColor>", "public" ] },
+    { include: [ "@\"(QtGui/)?qcursor\\.h\"", "private", "<QCursor>", "public" ] },
+    { include: [ "@\"(QtGui/)?qdesktopservices\\.h\"", "private", "<QDesktopServices>", "public" ] },
+    { include: [ "@\"(QtGui/)?qdrag\\.h\"", "private", "<QDrag>", "public" ] },
+    { include: [ "@\"(QtGui/)?qfont\\.h\"", "private", "<QFont>", "public" ] },
+    { include: [ "@\"(QtGui/)?qfontdatabase\\.h\"", "private", "<QFontDatabase>", "public" ] },
+    { include: [ "@\"(QtGui/)?qfontinfo\\.h\"", "private", "<QFontInfo>", "public" ] },
+    { include: [ "@\"(QtGui/)?qfontmetrics\\.h\"", "private", "<QFontMetrics>", "public" ] },
+    { include: [ "@\"(QtGui/)?qgenericmatrix\\.h\"", "private", "<QGenericMatrix>", "public" ] },
+    { include: [ "@\"(QtGui/)?qgenericplugin\\.h\"", "private", "<QGenericPlugin>", "public" ] },
+    { include: [ "@\"(QtGui/)?qgenericpluginfactory\\.h\"", "private", "<QGenericPluginFactory>", "public" ] },
+    { include: [ "@\"(QtGui/)?qglyphrun\\.h\"", "private", "<QGlyphRun>", "public" ] },
+    { include: [ "@\"(QtGui/)?qguiapplication\\.h\"", "private", "<QGuiApplication>", "public" ] },
+    { include: [ "@\"(QtGui/)?qicon\\.h\"", "private", "<QIcon>", "public" ] },
+    { include: [ "@\"(QtGui/)?qiconengine\\.h\"", "private", "<QIconEngine>", "public" ] },
+    { include: [ "@\"(QtGui/)?qiconengineplugin\\.h\"", "private", "<QIconEnginePlugin>", "public" ] },
+    { include: [ "@\"(QtGui/)?qimage\\.h\"", "private", "<QImage>", "public" ] },
+    { include: [ "@\"(QtGui/)?qimageiohandler\\.h\"", "private", "<QImageIOHandler>", "public" ] },
+    { include: [ "@\"(QtGui/)?qimagereader\\.h\"", "private", "<QImageReader>", "public" ] },
+    { include: [ "@\"(QtGui/)?qimagewriter\\.h\"", "private", "<QImageWriter>", "public" ] },
+    { include: [ "@\"(QtGui/)?qinputmethod\\.h\"", "private", "<QInputMethod>", "public" ] },
+    { include: [ "@\"(QtGui/)?qkeysequence\\.h\"", "private", "<QKeySequence>", "public" ] },
+    { include: [ "@\"(QtGui/)?qmatrix4x4\\.h\"", "private", "<QMatrix4x4>", "public" ] },
+    { include: [ "@\"(QtGui/)?qmatrix\\.h\"", "private", "<QMatrix>", "public" ] },
+    { include: [ "@\"(QtGui/)?qmovie\\.h\"", "private", "<QMovie>", "public" ] },
+    { include: [ "@\"(QtGui/)?qoffscreensurface\\.h\"", "private", "<QOffscreenSurface>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglbuffer\\.h\"", "private", "<QOpenGLBuffer>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglcontext\\.h\"", "private", "<QOpenGLContext>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglframebufferobject\\.h\"", "private", "<QOpenGLFramebufferObject>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions\\.h\"", "private", "<QOpenGLFunctions>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_1_0\\.h\"", "private", "<QOpenGLFunctions_1_0>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_1_1\\.h\"", "private", "<QOpenGLFunctions_1_1>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_1_2\\.h\"", "private", "<QOpenGLFunctions_1_2>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_1_3\\.h\"", "private", "<QOpenGLFunctions_1_3>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_1_4\\.h\"", "private", "<QOpenGLFunctions_1_4>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_1_5\\.h\"", "private", "<QOpenGLFunctions_1_5>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_2_0\\.h\"", "private", "<QOpenGLFunctions_2_0>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_2_1\\.h\"", "private", "<QOpenGLFunctions_2_1>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_3_0\\.h\"", "private", "<QOpenGLFunctions_3_0>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_3_1\\.h\"", "private", "<QOpenGLFunctions_3_1>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_3_2_compatibility\\.h\"", "private", "<QOpenGLFunctions_3_2_Compatibility>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_3_2_core\\.h\"", "private", "<QOpenGLFunctions_3_2_Core>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_3_3_compatibility\\.h\"", "private", "<QOpenGLFunctions_3_3_Compatibility>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_3_3_core\\.h\"", "private", "<QOpenGLFunctions_3_3_Core>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_4_0_compatibility\\.h\"", "private", "<QOpenGLFunctions_4_0_Compatibility>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_4_0_core\\.h\"", "private", "<QOpenGLFunctions_4_0_Core>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_4_1_compatibility\\.h\"", "private", "<QOpenGLFunctions_4_1_Compatibility>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_4_1_core\\.h\"", "private", "<QOpenGLFunctions_4_1_Core>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_4_2_compatibility\\.h\"", "private", "<QOpenGLFunctions_4_2_Compatibility>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_4_2_core\\.h\"", "private", "<QOpenGLFunctions_4_2_Core>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_4_3_compatibility\\.h\"", "private", "<QOpenGLFunctions_4_3_Compatibility>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_4_3_core\\.h\"", "private", "<QOpenGLFunctions_4_3_Core>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglfunctions_es2\\.h\"", "private", "<QOpenGLFunctions_ES2>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglpaintdevice\\.h\"", "private", "<QOpenGLPaintDevice>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglpixeltransferoptions\\.h\"", "private", "<QOpenGLPixelTransferOptions>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglshaderprogram\\.h\"", "private", "<QOpenGLShaderProgram>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopengltexture\\.h\"", "private", "<QOpenGLTexture>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopengltimerquery\\.h\"", "private", "<QOpenGLTimerQuery>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglversionfunctions\\.h\"", "private", "<QOpenGLVersionFunctions>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglvertexarrayobject\\.h\"", "private", "<QOpenGLVertexArrayObject>", "public" ] },
+    { include: [ "@\"(QtGui/)?qopenglwindow\\.h\"", "private", "<QOpenGLWindow>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpagedpaintdevice\\.h\"", "private", "<QPagedPaintDevice>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpagelayout\\.h\"", "private", "<QPageLayout>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpagesize\\.h\"", "private", "<QPageSize>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpaintdevice\\.h\"", "private", "<QPaintDevice>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpaintdevicewindow\\.h\"", "private", "<QPaintDeviceWindow>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpaintengine\\.h\"", "private", "<QPaintEngine>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpainter\\.h\"", "private", "<QPainter>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpainterpath\\.h\"", "private", "<QPainterPath>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpalette\\.h\"", "private", "<QPalette>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpdfwriter\\.h\"", "private", "<QPdfWriter>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpen\\.h\"", "private", "<QPen>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpicture\\.h\"", "private", "<QPicture>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpictureformatplugin\\.h\"", "private", "<QPictureFormatPlugin>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpixelformat\\.h\"", "private", "<QPixelFormat>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpixmap\\.h\"", "private", "<QPixmap>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpixmapcache\\.h\"", "private", "<QPixmapCache>", "public" ] },
+    { include: [ "@\"(QtGui/)?qpolygon\\.h\"", "private", "<QPolygon>", "public" ] },
+    { include: [ "@\"(QtGui/)?qquaternion\\.h\"", "private", "<QQuaternion>", "public" ] },
+    { include: [ "@\"(QtGui/)?qrasterwindow\\.h\"", "private", "<QRasterWindow>", "public" ] },
+    { include: [ "@\"(QtGui/)?qrawfont\\.h\"", "private", "<QRawFont>", "public" ] },
+    { include: [ "@\"(QtGui/)?qregion\\.h\"", "private", "<QRegion>", "public" ] },
+    { include: [ "@\"(QtGui/)?qrgb\\.h\"", "private", "<QRgb>", "public" ] },
+    { include: [ "@\"(QtGui/)?qscreen\\.h\"", "private", "<QScreen>", "public" ] },
+    { include: [ "@\"(QtGui/)?qsessionmanager\\.h\"", "private", "<QSessionManager>", "public" ] },
+    { include: [ "@\"(QtGui/)?qstandarditemmodel\\.h\"", "private", "<QStandardItemModel>", "public" ] },
+    { include: [ "@\"(QtGui/)?qstatictext\\.h\"", "private", "<QStaticText>", "public" ] },
+    { include: [ "@\"(QtGui/)?qstylehints\\.h\"", "private", "<QStyleHints>", "public" ] },
+    { include: [ "@\"(QtGui/)?qsurface\\.h\"", "private", "<QSurface>", "public" ] },
+    { include: [ "@\"(QtGui/)?qsurfaceformat\\.h\"", "private", "<QSurfaceFormat>", "public" ] },
+    { include: [ "@\"(QtGui/)?qsyntaxhighlighter\\.h\"", "private", "<QSyntaxHighlighter>", "public" ] },
+    { include: [ "@\"(QtGui/)?qtextcursor\\.h\"", "private", "<QTextCursor>", "public" ] },
+    { include: [ "@\"(QtGui/)?qtextdocument\\.h\"", "private", "<QTextDocument>", "public" ] },
+    { include: [ "@\"(QtGui/)?qtextdocumentfragment\\.h\"", "private", "<QTextDocumentFragment>", "public" ] },
+    { include: [ "@\"(QtGui/)?qtextdocumentwriter\\.h\"", "private", "<QTextDocumentWriter>", "public" ] },
+    { include: [ "@\"(QtGui/)?qtextformat\\.h\"", "private", "<QTextFormat>", "public" ] },
+    { include: [ "@\"(QtGui/)?qtextlayout\\.h\"", "private", "<QTextLayout>", "public" ] },
+    { include: [ "@\"(QtGui/)?qtextlist\\.h\"", "private", "<QTextList>", "public" ] },
+    { include: [ "@\"(QtGui/)?qtextobject\\.h\"", "private", "<QTextObject>", "public" ] },
+    { include: [ "@\"(QtGui/)?qtextoption\\.h\"", "private", "<QTextOption>", "public" ] },
+    { include: [ "@\"(QtGui/)?qtexttable\\.h\"", "private", "<QTextTable>", "public" ] },
+    { include: [ "@\"(QtGui/)?qtguiversion\\.h\"", "private", "<QtGuiVersion>", "public" ] },
+    { include: [ "@\"(QtGui/)?qtouchdevice\\.h\"", "private", "<QTouchDevice>", "public" ] },
+    { include: [ "@\"(QtGui/)?qtransform\\.h\"", "private", "<QTransform>", "public" ] },
+    { include: [ "@\"(QtGui/)?qvalidator\\.h\"", "private", "<QValidator>", "public" ] },
+    { include: [ "@\"(QtGui/)?qvector2d\\.h\"", "private", "<QVector2D>", "public" ] },
+    { include: [ "@\"(QtGui/)?qvector3d\\.h\"", "private", "<QVector3D>", "public" ] },
+    { include: [ "@\"(QtGui/)?qvector4d\\.h\"", "private", "<QVector4D>", "public" ] },
+    { include: [ "@\"(QtGui/)?qwindow\\.h\"", "private", "<QWindow>", "public" ] },
+    { include: [ "@\"(QtHelp/)?qhelpcontentwidget\\.h\"", "private", "<QHelpContentWidget>", "public" ] },
+    { include: [ "@\"(QtHelp/)?qhelpengine\\.h\"", "private", "<QHelpEngine>", "public" ] },
+    { include: [ "@\"(QtHelp/)?qhelpenginecore\\.h\"", "private", "<QHelpEngineCore>", "public" ] },
+    { include: [ "@\"(QtHelp/)?qhelpindexwidget\\.h\"", "private", "<QHelpIndexWidget>", "public" ] },
+    { include: [ "@\"(QtHelp/)?qhelpsearchengine\\.h\"", "private", "<QHelpSearchEngine>", "public" ] },
+    { include: [ "@\"(QtHelp/)?qhelpsearchquerywidget\\.h\"", "private", "<QHelpSearchQueryWidget>", "public" ] },
+    { include: [ "@\"(QtHelp/)?qhelpsearchresultwidget\\.h\"", "private", "<QHelpSearchResultWidget>", "public" ] },
+    { include: [ "@\"(QtHelp/)?qthelpversion\\.h\"", "private", "<QtHelpVersion>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qgeocodereply\\.h\"", "private", "<QGeoCodeReply>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qgeocodingmanager\\.h\"", "private", "<QGeoCodingManager>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qgeocodingmanagerengine\\.h\"", "private", "<QGeoCodingManagerEngine>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qgeomaneuver\\.h\"", "private", "<QGeoManeuver>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qgeoroute\\.h\"", "private", "<QGeoRoute>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qgeoroutereply\\.h\"", "private", "<QGeoRouteReply>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qgeorouterequest\\.h\"", "private", "<QGeoRouteRequest>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qgeoroutesegment\\.h\"", "private", "<QGeoRouteSegment>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qgeoroutingmanager\\.h\"", "private", "<QGeoRoutingManager>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qgeoroutingmanagerengine\\.h\"", "private", "<QGeoRoutingManagerEngine>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qgeoserviceprovider\\.h\"", "private", "<QGeoServiceProvider>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qgeoserviceproviderfactory\\.h\"", "private", "<QGeoServiceProviderFactory>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qlocation\\.h\"", "private", "<QLocation>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplace\\.h\"", "private", "<QPlace>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplaceattribute\\.h\"", "private", "<QPlaceAttribute>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacecategory\\.h\"", "private", "<QPlaceCategory>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacecontactdetail\\.h\"", "private", "<QPlaceContactDetail>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacecontent\\.h\"", "private", "<QPlaceContent>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacecontentreply\\.h\"", "private", "<QPlaceContentReply>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacecontentrequest\\.h\"", "private", "<QPlaceContentRequest>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacedetailsreply\\.h\"", "private", "<QPlaceDetailsReply>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplaceeditorial\\.h\"", "private", "<QPlaceEditorial>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplaceicon\\.h\"", "private", "<QPlaceIcon>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplaceidreply\\.h\"", "private", "<QPlaceIdReply>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplaceimage\\.h\"", "private", "<QPlaceImage>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacemanager\\.h\"", "private", "<QPlaceManager>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacemanagerengine\\.h\"", "private", "<QPlaceManagerEngine>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacematchreply\\.h\"", "private", "<QPlaceMatchReply>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacematchrequest\\.h\"", "private", "<QPlaceMatchRequest>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplaceproposedsearchresult\\.h\"", "private", "<QPlaceProposedSearchResult>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplaceratings\\.h\"", "private", "<QPlaceRatings>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacereply\\.h\"", "private", "<QPlaceReply>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplaceresult\\.h\"", "private", "<QPlaceResult>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacereview\\.h\"", "private", "<QPlaceReview>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacesearchreply\\.h\"", "private", "<QPlaceSearchReply>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacesearchrequest\\.h\"", "private", "<QPlaceSearchRequest>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacesearchresult\\.h\"", "private", "<QPlaceSearchResult>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacesearchsuggestionreply\\.h\"", "private", "<QPlaceSearchSuggestionReply>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplacesupplier\\.h\"", "private", "<QPlaceSupplier>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qplaceuser\\.h\"", "private", "<QPlaceUser>", "public" ] },
+    { include: [ "@\"(QtLocation/)?qtlocationversion\\.h\"", "private", "<QtLocationVersion>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qabstractvideobuffer\\.h\"", "private", "<QAbstractVideoBuffer>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qabstractvideosurface\\.h\"", "private", "<QAbstractVideoSurface>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qaudio\\.h\"", "private", "<QAudio>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qaudiobuffer\\.h\"", "private", "<QAudioBuffer>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qaudiodecoder\\.h\"", "private", "<QAudioDecoder>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qaudiodecodercontrol\\.h\"", "private", "<QAudioDecoderControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qaudiodeviceinfo\\.h\"", "private", "<QAudioDeviceInfo>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qaudioencodersettingscontrol\\.h\"", "private", "<QAudioEncoderSettingsControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qaudioformat\\.h\"", "private", "<QAudioFormat>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qaudioinput\\.h\"", "private", "<QAudioInput>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qaudioinputselectorcontrol\\.h\"", "private", "<QAudioInputSelectorControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qaudiooutput\\.h\"", "private", "<QAudioOutput>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qaudiooutputselectorcontrol\\.h\"", "private", "<QAudioOutputSelectorControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qaudioprobe\\.h\"", "private", "<QAudioProbe>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qaudiorecorder\\.h\"", "private", "<QAudioRecorder>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qaudiosystemplugin\\.h\"", "private", "<QAudioSystemPlugin>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcamera\\.h\"", "private", "<QCamera>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcameracapturebufferformatcontrol\\.h\"", "private", "<QCameraCaptureBufferFormatControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcameracapturedestinationcontrol\\.h\"", "private", "<QCameraCaptureDestinationControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcameracontrol\\.h\"", "private", "<QCameraControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcameraexposure\\.h\"", "private", "<QCameraExposure>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcameraexposurecontrol\\.h\"", "private", "<QCameraExposureControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcamerafeedbackcontrol\\.h\"", "private", "<QCameraFeedbackControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcameraflashcontrol\\.h\"", "private", "<QCameraFlashControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcamerafocus\\.h\"", "private", "<QCameraFocus>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcamerafocuscontrol\\.h\"", "private", "<QCameraFocusControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcameraimagecapture\\.h\"", "private", "<QCameraImageCapture>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcameraimagecapturecontrol\\.h\"", "private", "<QCameraImageCaptureControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcameraimageprocessing\\.h\"", "private", "<QCameraImageProcessing>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcameraimageprocessingcontrol\\.h\"", "private", "<QCameraImageProcessingControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcamerainfo\\.h\"", "private", "<QCameraInfo>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcamerainfocontrol\\.h\"", "private", "<QCameraInfoControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcameralockscontrol\\.h\"", "private", "<QCameraLocksControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcameraviewfindersettingscontrol\\.h\"", "private", "<QCameraViewfinderSettingsControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qcamerazoomcontrol\\.h\"", "private", "<QCameraZoomControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qimageencodercontrol\\.h\"", "private", "<QImageEncoderControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediaaudioprobecontrol\\.h\"", "private", "<QMediaAudioProbeControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediaavailabilitycontrol\\.h\"", "private", "<QMediaAvailabilityControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediabindableinterface\\.h\"", "private", "<QMediaBindableInterface>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediacontainercontrol\\.h\"", "private", "<QMediaContainerControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediacontent\\.h\"", "private", "<QMediaContent>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediacontrol\\.h\"", "private", "<QMediaControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediagaplessplaybackcontrol\\.h\"", "private", "<QMediaGaplessPlaybackControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediametadata\\.h\"", "private", "<QMediaMetaData>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmedianetworkaccesscontrol\\.h\"", "private", "<QMediaNetworkAccessControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediaobject\\.h\"", "private", "<QMediaObject>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediaplayer\\.h\"", "private", "<QMediaPlayer>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediaplayercontrol\\.h\"", "private", "<QMediaPlayerControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediaplaylist\\.h\"", "private", "<QMediaPlaylist>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediarecorder\\.h\"", "private", "<QMediaRecorder>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediarecordercontrol\\.h\"", "private", "<QMediaRecorderControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediaresource\\.h\"", "private", "<QMediaResource>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediaservice\\.h\"", "private", "<QMediaService>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediaserviceproviderplugin\\.h\"", "private", "<QMediaServiceProviderPlugin>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediastreamscontrol\\.h\"", "private", "<QMediaStreamsControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediatimerange\\.h\"", "private", "<QMediaTimeRange>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmediavideoprobecontrol\\.h\"", "private", "<QMediaVideoProbeControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmetadatareadercontrol\\.h\"", "private", "<QMetaDataReaderControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmetadatawritercontrol\\.h\"", "private", "<QMetaDataWriterControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qmultimedia\\.h\"", "private", "<QMultimedia>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qradiodata\\.h\"", "private", "<QRadioData>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qradiodatacontrol\\.h\"", "private", "<QRadioDataControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qradiotuner\\.h\"", "private", "<QRadioTuner>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qradiotunercontrol\\.h\"", "private", "<QRadioTunerControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qsound\\.h\"", "private", "<QSound>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qsoundeffect\\.h\"", "private", "<QSoundEffect>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qtmultimediaversion\\.h\"", "private", "<QtMultimediaVersion>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qvideodeviceselectorcontrol\\.h\"", "private", "<QVideoDeviceSelectorControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qvideoencodersettingscontrol\\.h\"", "private", "<QVideoEncoderSettingsControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qvideoframe\\.h\"", "private", "<QVideoFrame>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qvideoprobe\\.h\"", "private", "<QVideoProbe>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qvideorenderercontrol\\.h\"", "private", "<QVideoRendererControl>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qvideosurfaceformat\\.h\"", "private", "<QVideoSurfaceFormat>", "public" ] },
+    { include: [ "@\"(QtMultimedia/)?qvideowindowcontrol\\.h\"", "private", "<QVideoWindowControl>", "public" ] },
+    { include: [ "@\"(QtMultimediaQuick_p/)?qsgvideonode_i420\\.h\"", "private", "<QSGVideoNode_I420>", "public" ] },
+    { include: [ "@\"(QtMultimediaQuick_p/)?qsgvideonode_rgb\\.h\"", "private", "<QSGVideoNode_RGB>", "public" ] },
+    { include: [ "@\"(QtMultimediaQuick_p/)?qsgvideonode_texture\\.h\"", "private", "<QSGVideoNode_Texture>", "public" ] },
+    { include: [ "@\"(QtMultimediaQuick_p/)?qtmultimediaquick_pversion\\.h\"", "private", "<QtMultimediaQuick_pVersion>", "public" ] },
+    { include: [ "@\"(QtMultimediaWidgets/)?qcameraviewfinder\\.h\"", "private", "<QCameraViewfinder>", "public" ] },
+    { include: [ "@\"(QtMultimediaWidgets/)?qgraphicsvideoitem\\.h\"", "private", "<QGraphicsVideoItem>", "public" ] },
+    { include: [ "@\"(QtMultimediaWidgets/)?qtmultimediawidgetsversion\\.h\"", "private", "<QtMultimediaWidgetsVersion>", "public" ] },
+    { include: [ "@\"(QtMultimediaWidgets/)?qvideowidget\\.h\"", "private", "<QVideoWidget>", "public" ] },
+    { include: [ "@\"(QtMultimediaWidgets/)?qvideowidgetcontrol\\.h\"", "private", "<QVideoWidgetControl>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qabstractnetworkcache\\.h\"", "private", "<QAbstractNetworkCache>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qabstractsocket\\.h\"", "private", "<QAbstractSocket>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qauthenticator\\.h\"", "private", "<QAuthenticator>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qdnslookup\\.h\"", "private", "<QDnsLookup>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qhostaddress\\.h\"", "private", "<QHostAddress>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qhostinfo\\.h\"", "private", "<QHostInfo>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qhttpmultipart\\.h\"", "private", "<QHttpMultiPart>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qlocalserver\\.h\"", "private", "<QLocalServer>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qlocalsocket\\.h\"", "private", "<QLocalSocket>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qnetworkaccessmanager\\.h\"", "private", "<QNetworkAccessManager>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qnetworkconfiguration\\.h\"", "private", "<QNetworkConfiguration>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qnetworkcookie\\.h\"", "private", "<QNetworkCookie>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qnetworkcookiejar\\.h\"", "private", "<QNetworkCookieJar>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qnetworkdiskcache\\.h\"", "private", "<QNetworkDiskCache>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qnetworkinterface\\.h\"", "private", "<QNetworkInterface>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qnetworkproxy\\.h\"", "private", "<QNetworkProxy>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qnetworkreply\\.h\"", "private", "<QNetworkReply>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qnetworkrequest\\.h\"", "private", "<QNetworkRequest>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qnetworksession\\.h\"", "private", "<QNetworkSession>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qssl\\.h\"", "private", "<QSsl>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qsslcertificate\\.h\"", "private", "<QSslCertificate>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qsslcertificateextension\\.h\"", "private", "<QSslCertificateExtension>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qsslcipher\\.h\"", "private", "<QSslCipher>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qsslconfiguration\\.h\"", "private", "<QSslConfiguration>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qsslerror\\.h\"", "private", "<QSslError>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qsslkey\\.h\"", "private", "<QSslKey>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qsslsocket\\.h\"", "private", "<QSslSocket>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qtcpserver\\.h\"", "private", "<QTcpServer>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qtcpsocket\\.h\"", "private", "<QTcpSocket>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qtnetworkversion\\.h\"", "private", "<QtNetworkVersion>", "public" ] },
+    { include: [ "@\"(QtNetwork/)?qudpsocket\\.h\"", "private", "<QUdpSocket>", "public" ] },
+    { include: [ "@\"(QtNfc/)?qndeffilter\\.h\"", "private", "<QNdefFilter>", "public" ] },
+    { include: [ "@\"(QtNfc/)?qndefmessage\\.h\"", "private", "<QNdefMessage>", "public" ] },
+    { include: [ "@\"(QtNfc/)?qndefnfcsmartposterrecord\\.h\"", "private", "<QNdefNfcSmartPosterRecord>", "public" ] },
+    { include: [ "@\"(QtNfc/)?qndefnfctextrecord\\.h\"", "private", "<QNdefNfcTextRecord>", "public" ] },
+    { include: [ "@\"(QtNfc/)?qndefnfcurirecord\\.h\"", "private", "<QNdefNfcUriRecord>", "public" ] },
+    { include: [ "@\"(QtNfc/)?qndefrecord\\.h\"", "private", "<QNdefRecord>", "public" ] },
+    { include: [ "@\"(QtNfc/)?qnearfieldmanager\\.h\"", "private", "<QNearFieldManager>", "public" ] },
+    { include: [ "@\"(QtNfc/)?qnearfieldsharemanager\\.h\"", "private", "<QNearFieldShareManager>", "public" ] },
+    { include: [ "@\"(QtNfc/)?qnearfieldsharetarget\\.h\"", "private", "<QNearFieldShareTarget>", "public" ] },
+    { include: [ "@\"(QtNfc/)?qnearfieldtarget\\.h\"", "private", "<QNearFieldTarget>", "public" ] },
+    { include: [ "@\"(QtNfc/)?qqmlndefrecord\\.h\"", "private", "<QQmlNdefRecord>", "public" ] },
+    { include: [ "@\"(QtNfc/)?qtnfcversion\\.h\"", "private", "<QtNfcVersion>", "public" ] },
+    { include: [ "@\"(QtOpenGL/)?qgl\\.h\"", "private", "<QGL>", "public" ] },
+    { include: [ "@\"(QtOpenGL/)?qglbuffer\\.h\"", "private", "<QGLBuffer>", "public" ] },
+    { include: [ "@\"(QtOpenGL/)?qglcolormap\\.h\"", "private", "<QGLColormap>", "public" ] },
+    { include: [ "@\"(QtOpenGL/)?qglframebufferobject\\.h\"", "private", "<QGLFramebufferObject>", "public" ] },
+    { include: [ "@\"(QtOpenGL/)?qglfunctions\\.h\"", "private", "<QGLFunctions>", "public" ] },
+    { include: [ "@\"(QtOpenGL/)?qglpixelbuffer\\.h\"", "private", "<QGLPixelBuffer>", "public" ] },
+    { include: [ "@\"(QtOpenGL/)?qglshaderprogram\\.h\"", "private", "<QGLShaderProgram>", "public" ] },
+    { include: [ "@\"(QtOpenGL/)?qtopenglversion\\.h\"", "private", "<QtOpenGLVersion>", "public" ] },
+    { include: [ "@\"(QtOpenGLExtensions/)?qopenglextensions\\.h\"", "private", "<QOpenGLExtensions>", "public" ] },
+    { include: [ "@\"(QtOpenGLExtensions/)?qtopenglextensionsversion\\.h\"", "private", "<QtOpenGLExtensionsVersion>", "public" ] },
+    { include: [ "@\"(QtPlatformHeaders/)?qcocoanativecontext\\.h\"", "private", "<QCocoaNativeContext>", "public" ] },
+    { include: [ "@\"(QtPlatformHeaders/)?qeglfsfunctions\\.h\"", "private", "<QEglFSFunctions>", "public" ] },
+    { include: [ "@\"(QtPlatformHeaders/)?qeglnativecontext\\.h\"", "private", "<QEGLNativeContext>", "public" ] },
+    { include: [ "@\"(QtPlatformHeaders/)?qglxnativecontext\\.h\"", "private", "<QGLXNativeContext>", "public" ] },
+    { include: [ "@\"(QtPlatformHeaders/)?qtplatformheadersversion\\.h\"", "private", "<QtPlatformHeadersVersion>", "public" ] },
+    { include: [ "@\"(QtPlatformHeaders/)?qwglnativecontext\\.h\"", "private", "<QWGLNativeContext>", "public" ] },
+    { include: [ "@\"(QtPlatformHeaders/)?qxcbwindowfunctions\\.h\"", "private", "<QXcbWindowFunctions>", "public" ] },
+    { include: [ "@\"(QtPlatformSupport/)?qtplatformsupportversion\\.h\"", "private", "<QtPlatformSupportVersion>", "public" ] },
+    { include: [ "@\"(QtPositioning/)?qgeoaddress\\.h\"", "private", "<QGeoAddress>", "public" ] },
+    { include: [ "@\"(QtPositioning/)?qgeoareamonitorinfo\\.h\"", "private", "<QGeoAreaMonitorInfo>", "public" ] },
+    { include: [ "@\"(QtPositioning/)?qgeoareamonitorsource\\.h\"", "private", "<QGeoAreaMonitorSource>", "public" ] },
+    { include: [ "@\"(QtPositioning/)?qgeocircle\\.h\"", "private", "<QGeoCircle>", "public" ] },
+    { include: [ "@\"(QtPositioning/)?qgeocoordinate\\.h\"", "private", "<QGeoCoordinate>", "public" ] },
+    { include: [ "@\"(QtPositioning/)?qgeolocation\\.h\"", "private", "<QGeoLocation>", "public" ] },
+    { include: [ "@\"(QtPositioning/)?qgeopositioninfo\\.h\"", "private", "<QGeoPositionInfo>", "public" ] },
+    { include: [ "@\"(QtPositioning/)?qgeopositioninfosource\\.h\"", "private", "<QGeoPositionInfoSource>", "public" ] },
+    { include: [ "@\"(QtPositioning/)?qgeopositioninfosourcefactory\\.h\"", "private", "<QGeoPositionInfoSourceFactory>", "public" ] },
+    { include: [ "@\"(QtPositioning/)?qgeorectangle\\.h\"", "private", "<QGeoRectangle>", "public" ] },
+    { include: [ "@\"(QtPositioning/)?qgeosatelliteinfo\\.h\"", "private", "<QGeoSatelliteInfo>", "public" ] },
+    { include: [ "@\"(QtPositioning/)?qgeosatelliteinfosource\\.h\"", "private", "<QGeoSatelliteInfoSource>", "public" ] },
+    { include: [ "@\"(QtPositioning/)?qgeoshape\\.h\"", "private", "<QGeoShape>", "public" ] },
+    { include: [ "@\"(QtPositioning/)?qnmeapositioninfosource\\.h\"", "private", "<QNmeaPositionInfoSource>", "public" ] },
+    { include: [ "@\"(QtPositioning/)?qtpositioningversion\\.h\"", "private", "<QtPositioningVersion>", "public" ] },
+    { include: [ "@\"(QtPrintSupport/)?qabstractprintdialog\\.h\"", "private", "<QAbstractPrintDialog>", "public" ] },
+    { include: [ "@\"(QtPrintSupport/)?qpagesetupdialog\\.h\"", "private", "<QPageSetupDialog>", "public" ] },
+    { include: [ "@\"(QtPrintSupport/)?qprintdialog\\.h\"", "private", "<QPrintDialog>", "public" ] },
+    { include: [ "@\"(QtPrintSupport/)?qprintengine\\.h\"", "private", "<QPrintEngine>", "public" ] },
+    { include: [ "@\"(QtPrintSupport/)?qprinter\\.h\"", "private", "<QPrinter>", "public" ] },
+    { include: [ "@\"(QtPrintSupport/)?qprinterinfo\\.h\"", "private", "<QPrinterInfo>", "public" ] },
+    { include: [ "@\"(QtPrintSupport/)?qprintpreviewdialog\\.h\"", "private", "<QPrintPreviewDialog>", "public" ] },
+    { include: [ "@\"(QtPrintSupport/)?qprintpreviewwidget\\.h\"", "private", "<QPrintPreviewWidget>", "public" ] },
+    { include: [ "@\"(QtPrintSupport/)?qtprintsupportversion\\.h\"", "private", "<QtPrintSupportVersion>", "public" ] },
+    { include: [ "@\"(QtQml/)?qjsengine\\.h\"", "private", "<QJSEngine>", "public" ] },
+    { include: [ "@\"(QtQml/)?qjsvalue\\.h\"", "private", "<QJSValue>", "public" ] },
+    { include: [ "@\"(QtQml/)?qjsvalueiterator\\.h\"", "private", "<QJSValueIterator>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlabstracturlinterceptor\\.h\"", "private", "<QQmlAbstractUrlInterceptor>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlapplicationengine\\.h\"", "private", "<QQmlApplicationEngine>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlcomponent\\.h\"", "private", "<QQmlComponent>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlcontext\\.h\"", "private", "<QQmlContext>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlengine\\.h\"", "private", "<QQmlEngine>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlerror\\.h\"", "private", "<QQmlError>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlexpression\\.h\"", "private", "<QQmlExpression>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlextensioninterface\\.h\"", "private", "<QQmlExtensionInterface>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlextensionplugin\\.h\"", "private", "<QQmlExtensionPlugin>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlfile\\.h\"", "private", "<QQmlFile>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlfileselector\\.h\"", "private", "<QQmlFileSelector>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlincubator\\.h\"", "private", "<QQmlIncubator>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlinfo\\.h\"", "private", "<QQmlInfo>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlnetworkaccessmanagerfactory\\.h\"", "private", "<QQmlNetworkAccessManagerFactory>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlparserstatus\\.h\"", "private", "<QQmlParserStatus>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlproperty\\.h\"", "private", "<QQmlProperty>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlpropertymap\\.h\"", "private", "<QQmlPropertyMap>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlpropertyvaluesource\\.h\"", "private", "<QQmlPropertyValueSource>", "public" ] },
+    { include: [ "@\"(QtQml/)?qqmlscriptstring\\.h\"", "private", "<QQmlScriptString>", "public" ] },
+    { include: [ "@\"(QtQml/)?qtqmlversion\\.h\"", "private", "<QtQmlVersion>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qquickframebufferobject\\.h\"", "private", "<QQuickFramebufferObject>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qquickimageprovider\\.h\"", "private", "<QQuickImageProvider>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qquickitem\\.h\"", "private", "<QQuickItem>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qquickitemgrabresult\\.h\"", "private", "<QQuickItemGrabResult>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qquickpainteditem\\.h\"", "private", "<QQuickPaintedItem>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qquickrendercontrol\\.h\"", "private", "<QQuickRenderControl>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qquicktextdocument\\.h\"", "private", "<QQuickTextDocument>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qquickview\\.h\"", "private", "<QQuickView>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qquickwindow\\.h\"", "private", "<QQuickWindow>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qsgabstractrenderer\\.h\"", "private", "<QSGAbstractRenderer>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qsgengine\\.h\"", "private", "<QSGEngine>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qsgflatcolormaterial\\.h\"", "private", "<QSGFlatColorMaterial>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qsggeometry\\.h\"", "private", "<QSGGeometry>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qsgmaterial\\.h\"", "private", "<QSGMaterial>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qsgnode\\.h\"", "private", "<QSGNode>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qsgsimplematerial\\.h\"", "private", "<QSGSimpleMaterial>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qsgsimplerectnode\\.h\"", "private", "<QSGSimpleRectNode>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qsgsimpletexturenode\\.h\"", "private", "<QSGSimpleTextureNode>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qsgtexture\\.h\"", "private", "<QSGTexture>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qsgtexturematerial\\.h\"", "private", "<QSGTextureMaterial>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qsgtextureprovider\\.h\"", "private", "<QSGTextureProvider>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qsgvertexcolormaterial\\.h\"", "private", "<QSGVertexColorMaterial>", "public" ] },
+    { include: [ "@\"(QtQuick/)?qtquickversion\\.h\"", "private", "<QtQuickVersion>", "public" ] },
+    { include: [ "@\"(QtQuickParticles/)?qtquickparticlesversion\\.h\"", "private", "<QtQuickParticlesVersion>", "public" ] },
+    { include: [ "@\"(QtQuickTest/)?qtquicktestversion\\.h\"", "private", "<QtQuickTestVersion>", "public" ] },
+    { include: [ "@\"(QtQuickWidgets/)?qquickwidget\\.h\"", "private", "<QQuickWidget>", "public" ] },
+    { include: [ "@\"(QtQuickWidgets/)?qtquickwidgetsversion\\.h\"", "private", "<QtQuickWidgetsVersion>", "public" ] },
+    { include: [ "@\"(QtScript/)?qscriptable\\.h\"", "private", "<QScriptable>", "public" ] },
+    { include: [ "@\"(QtScript/)?qscriptclass\\.h\"", "private", "<QScriptClass>", "public" ] },
+    { include: [ "@\"(QtScript/)?qscriptclasspropertyiterator\\.h\"", "private", "<QScriptClassPropertyIterator>", "public" ] },
+    { include: [ "@\"(QtScript/)?qscriptcontext\\.h\"", "private", "<QScriptContext>", "public" ] },
+    { include: [ "@\"(QtScript/)?qscriptcontextinfo\\.h\"", "private", "<QScriptContextInfo>", "public" ] },
+    { include: [ "@\"(QtScript/)?qscriptengine\\.h\"", "private", "<QScriptEngine>", "public" ] },
+    { include: [ "@\"(QtScript/)?qscriptengineagent\\.h\"", "private", "<QScriptEngineAgent>", "public" ] },
+    { include: [ "@\"(QtScript/)?qscriptextensioninterface\\.h\"", "private", "<QScriptExtensionInterface>", "public" ] },
+    { include: [ "@\"(QtScript/)?qscriptextensionplugin\\.h\"", "private", "<QScriptExtensionPlugin>", "public" ] },
+    { include: [ "@\"(QtScript/)?qscriptprogram\\.h\"", "private", "<QScriptProgram>", "public" ] },
+    { include: [ "@\"(QtScript/)?qscriptstring\\.h\"", "private", "<QScriptString>", "public" ] },
+    { include: [ "@\"(QtScript/)?qscriptvalue\\.h\"", "private", "<QScriptValue>", "public" ] },
+    { include: [ "@\"(QtScript/)?qscriptvalueiterator\\.h\"", "private", "<QScriptValueIterator>", "public" ] },
+    { include: [ "@\"(QtScript/)?qtscriptversion\\.h\"", "private", "<QtScriptVersion>", "public" ] },
+    { include: [ "@\"(QtScriptTools/)?qscriptenginedebugger\\.h\"", "private", "<QScriptEngineDebugger>", "public" ] },
+    { include: [ "@\"(QtScriptTools/)?qtscripttoolsversion\\.h\"", "private", "<QtScriptToolsVersion>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qaccelerometer\\.h\"", "private", "<QAccelerometer>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qaltimeter\\.h\"", "private", "<QAltimeter>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qambientlightsensor\\.h\"", "private", "<QAmbientLightSensor>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qambienttemperaturesensor\\.h\"", "private", "<QAmbientTemperatureSensor>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qcompass\\.h\"", "private", "<QCompass>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qdistancesensor\\.h\"", "private", "<QDistanceSensor>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qgyroscope\\.h\"", "private", "<QGyroscope>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qholstersensor\\.h\"", "private", "<QHolsterSensor>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qirproximitysensor\\.h\"", "private", "<QIRProximitySensor>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qlightsensor\\.h\"", "private", "<QLightSensor>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qmagnetometer\\.h\"", "private", "<QMagnetometer>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qorientationsensor\\.h\"", "private", "<QOrientationSensor>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qpressuresensor\\.h\"", "private", "<QPressureSensor>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qproximitysensor\\.h\"", "private", "<QProximitySensor>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qrotationsensor\\.h\"", "private", "<QRotationSensor>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qsensor\\.h\"", "private", "<QSensor>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qsensorbackend\\.h\"", "private", "<QSensorBackend>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qsensorgesture\\.h\"", "private", "<QSensorGesture>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qsensorgesturemanager\\.h\"", "private", "<QSensorGestureManager>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qsensorgestureplugininterface\\.h\"", "private", "<QSensorGesturePluginInterface>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qsensorgesturerecognizer\\.h\"", "private", "<QSensorGestureRecognizer>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qsensormanager\\.h\"", "private", "<QSensorManager>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qtapsensor\\.h\"", "private", "<QTapSensor>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qtiltsensor\\.h\"", "private", "<QTiltSensor>", "public" ] },
+    { include: [ "@\"(QtSensors/)?qtsensorsversion\\.h\"", "private", "<QtSensorsVersion>", "public" ] },
+    { include: [ "@\"(QtSerialPort/)?qlockfile\\.h\"", "private", "<QLockFile>", "public" ] },
+    { include: [ "@\"(QtSerialPort/)?qserialport\\.h\"", "private", "<QSerialPort>", "public" ] },
+    { include: [ "@\"(QtSerialPort/)?qserialportinfo\\.h\"", "private", "<QSerialPortInfo>", "public" ] },
+    { include: [ "@\"(QtSerialPort/)?qtserialportversion\\.h\"", "private", "<QtSerialPortVersion>", "public" ] },
+    { include: [ "@\"(QtSerialPort/)?qwineventnotifier\\.h\"", "private", "<QWinEventNotifier>", "public" ] },
+    { include: [ "@\"(QtSql/)?qsql\\.h\"", "private", "<QSql>", "public" ] },
+    { include: [ "@\"(QtSql/)?qsqldatabase\\.h\"", "private", "<QSqlDatabase>", "public" ] },
+    { include: [ "@\"(QtSql/)?qsqldriver\\.h\"", "private", "<QSqlDriver>", "public" ] },
+    { include: [ "@\"(QtSql/)?qsqldriverplugin\\.h\"", "private", "<QSqlDriverPlugin>", "public" ] },
+    { include: [ "@\"(QtSql/)?qsqlerror\\.h\"", "private", "<QSqlError>", "public" ] },
+    { include: [ "@\"(QtSql/)?qsqlfield\\.h\"", "private", "<QSqlField>", "public" ] },
+    { include: [ "@\"(QtSql/)?qsqlindex\\.h\"", "private", "<QSqlIndex>", "public" ] },
+    { include: [ "@\"(QtSql/)?qsqlquery\\.h\"", "private", "<QSqlQuery>", "public" ] },
+    { include: [ "@\"(QtSql/)?qsqlquerymodel\\.h\"", "private", "<QSqlQueryModel>", "public" ] },
+    { include: [ "@\"(QtSql/)?qsqlrecord\\.h\"", "private", "<QSqlRecord>", "public" ] },
+    { include: [ "@\"(QtSql/)?qsqlrelationaldelegate\\.h\"", "private", "<QSqlRelationalDelegate>", "public" ] },
+    { include: [ "@\"(QtSql/)?qsqlrelationaltablemodel\\.h\"", "private", "<QSqlRelationalTableModel>", "public" ] },
+    { include: [ "@\"(QtSql/)?qsqlresult\\.h\"", "private", "<QSqlResult>", "public" ] },
+    { include: [ "@\"(QtSql/)?qsqltablemodel\\.h\"", "private", "<QSqlTableModel>", "public" ] },
+    { include: [ "@\"(QtSql/)?qtsqlversion\\.h\"", "private", "<QtSqlVersion>", "public" ] },
+    { include: [ "@\"(QtSvg/)?qgraphicssvgitem\\.h\"", "private", "<QGraphicsSvgItem>", "public" ] },
+    { include: [ "@\"(QtSvg/)?qsvggenerator\\.h\"", "private", "<QSvgGenerator>", "public" ] },
+    { include: [ "@\"(QtSvg/)?qsvgrenderer\\.h\"", "private", "<QSvgRenderer>", "public" ] },
+    { include: [ "@\"(QtSvg/)?qsvgwidget\\.h\"", "private", "<QSvgWidget>", "public" ] },
+    { include: [ "@\"(QtSvg/)?qtsvgversion\\.h\"", "private", "<QtSvgVersion>", "public" ] },
+    { include: [ "@\"(QtTest/)?qsignalspy\\.h\"", "private", "<QSignalSpy>", "public" ] },
+    { include: [ "@\"(QtTest/)?qtest\\.h\"", "private", "<QTest>", "public" ] },
+    { include: [ "@\"(QtTest/)?qtestdata\\.h\"", "private", "<QTestData>", "public" ] },
+    { include: [ "@\"(QtTest/)?qtestevent\\.h\"", "private", "<QTestEvent>", "public" ] },
+    { include: [ "@\"(QtTest/)?qtesteventloop\\.h\"", "private", "<QTestEventLoop>", "public" ] },
+    { include: [ "@\"(QtTest/)?qttestversion\\.h\"", "private", "<QtTestVersion>", "public" ] },
+    { include: [ "@\"(QtUiTools/)?qtuitoolsversion\\.h\"", "private", "<QtUiToolsVersion>", "public" ] },
+    { include: [ "@\"(QtUiTools/)?quiloader\\.h\"", "private", "<QUiLoader>", "public" ] },
+    { include: [ "@\"(QtWebChannel/)?qqmlwebchannel\\.h\"", "private", "<QQmlWebChannel>", "public" ] },
+    { include: [ "@\"(QtWebChannel/)?qtwebchannelversion\\.h\"", "private", "<QtWebChannelVersion>", "public" ] },
+    { include: [ "@\"(QtWebChannel/)?qwebchannel\\.h\"", "private", "<QWebChannel>", "public" ] },
+    { include: [ "@\"(QtWebChannel/)?qwebchannelabstracttransport\\.h\"", "private", "<QWebChannelAbstractTransport>", "public" ] },
+    { include: [ "@\"(QtWebKit/)?qtwebkitversion\\.h\"", "private", "<QtWebKitVersion>", "public" ] },
+    { include: [ "@\"(QtWebKit/)?qwebdatabase\\.h\"", "private", "<QWebDatabase>", "public" ] },
+    { include: [ "@\"(QtWebKit/)?qwebelement\\.h\"", "private", "<QWebElement>", "public" ] },
+    { include: [ "@\"(QtWebKit/)?qwebhistory\\.h\"", "private", "<QWebHistory>", "public" ] },
+    { include: [ "@\"(QtWebKit/)?qwebhistoryinterface\\.h\"", "private", "<QWebHistoryInterface>", "public" ] },
+    { include: [ "@\"(QtWebKit/)?qwebkitplatformplugin\\.h\"", "private", "<QWebKitPlatformPlugin>", "public" ] },
+    { include: [ "@\"(QtWebKit/)?qwebpluginfactory\\.h\"", "private", "<QWebPluginFactory>", "public" ] },
+    { include: [ "@\"(QtWebKit/)?qwebsecurityorigin\\.h\"", "private", "<QWebSecurityOrigin>", "public" ] },
+    { include: [ "@\"(QtWebKit/)?qwebsettings\\.h\"", "private", "<QWebSettings>", "public" ] },
+    { include: [ "@\"(QtWebKitWidgets/)?qgraphicswebview\\.h\"", "private", "<QGraphicsWebView>", "public" ] },
+    { include: [ "@\"(QtWebKitWidgets/)?qtwebkitwidgetsversion\\.h\"", "private", "<QtWebKitWidgetsVersion>", "public" ] },
+    { include: [ "@\"(QtWebKitWidgets/)?qwebframe\\.h\"", "private", "<QWebFrame>", "public" ] },
+    { include: [ "@\"(QtWebKitWidgets/)?qwebinspector\\.h\"", "private", "<QWebInspector>", "public" ] },
+    { include: [ "@\"(QtWebKitWidgets/)?qwebpage\\.h\"", "private", "<QWebPage>", "public" ] },
+    { include: [ "@\"(QtWebKitWidgets/)?qwebview\\.h\"", "private", "<QWebView>", "public" ] },
+    { include: [ "@\"(QtWebSockets/)?qmaskgenerator\\.h\"", "private", "<QMaskGenerator>", "public" ] },
+    { include: [ "@\"(QtWebSockets/)?qtwebsocketsversion\\.h\"", "private", "<QtWebSocketsVersion>", "public" ] },
+    { include: [ "@\"(QtWebSockets/)?qwebsocket\\.h\"", "private", "<QWebSocket>", "public" ] },
+    { include: [ "@\"(QtWebSockets/)?qwebsocketcorsauthenticator\\.h\"", "private", "<QWebSocketCorsAuthenticator>", "public" ] },
+    { include: [ "@\"(QtWebSockets/)?qwebsocketserver\\.h\"", "private", "<QWebSocketServer>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qabstractbutton\\.h\"", "private", "<QAbstractButton>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qabstractitemdelegate\\.h\"", "private", "<QAbstractItemDelegate>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qabstractitemview\\.h\"", "private", "<QAbstractItemView>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qabstractscrollarea\\.h\"", "private", "<QAbstractScrollArea>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qabstractslider\\.h\"", "private", "<QAbstractSlider>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qabstractspinbox\\.h\"", "private", "<QAbstractSpinBox>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qaccessiblemenu\\.h\"", "private", "<QAccessibleMenu>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qaccessiblewidget\\.h\"", "private", "<QAccessibleWidget>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qaction\\.h\"", "private", "<QAction>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qactiongroup\\.h\"", "private", "<QActionGroup>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qapplication\\.h\"", "private", "<QApplication>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qboxlayout\\.h\"", "private", "<QBoxLayout>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qbuttongroup\\.h\"", "private", "<QButtonGroup>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qcalendarwidget\\.h\"", "private", "<QCalendarWidget>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qcheckbox\\.h\"", "private", "<QCheckBox>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qcolordialog\\.h\"", "private", "<QColorDialog>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qcolormap\\.h\"", "private", "<QColormap>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qcolumnview\\.h\"", "private", "<QColumnView>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qcombobox\\.h\"", "private", "<QComboBox>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qcommandlinkbutton\\.h\"", "private", "<QCommandLinkButton>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qcommonstyle\\.h\"", "private", "<QCommonStyle>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qcompleter\\.h\"", "private", "<QCompleter>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qdatawidgetmapper\\.h\"", "private", "<QDataWidgetMapper>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qdatetimeedit\\.h\"", "private", "<QDateTimeEdit>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qdesktopwidget\\.h\"", "private", "<QDesktopWidget>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qdial\\.h\"", "private", "<QDial>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qdialog\\.h\"", "private", "<QDialog>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qdialogbuttonbox\\.h\"", "private", "<QDialogButtonBox>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qdirmodel\\.h\"", "private", "<QDirModel>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qdockwidget\\.h\"", "private", "<QDockWidget>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qerrormessage\\.h\"", "private", "<QErrorMessage>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qfiledialog\\.h\"", "private", "<QFileDialog>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qfileiconprovider\\.h\"", "private", "<QFileIconProvider>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qfilesystemmodel\\.h\"", "private", "<QFileSystemModel>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qfocusframe\\.h\"", "private", "<QFocusFrame>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qfontcombobox\\.h\"", "private", "<QFontComboBox>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qfontdialog\\.h\"", "private", "<QFontDialog>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qformlayout\\.h\"", "private", "<QFormLayout>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qframe\\.h\"", "private", "<QFrame>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgesture\\.h\"", "private", "<QGesture>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgesturerecognizer\\.h\"", "private", "<QGestureRecognizer>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgraphicsanchorlayout\\.h\"", "private", "<QGraphicsAnchorLayout>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgraphicseffect\\.h\"", "private", "<QGraphicsEffect>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgraphicsgridlayout\\.h\"", "private", "<QGraphicsGridLayout>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgraphicsitem\\.h\"", "private", "<QGraphicsItem>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgraphicsitemanimation\\.h\"", "private", "<QGraphicsItemAnimation>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgraphicslayout\\.h\"", "private", "<QGraphicsLayout>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgraphicslayoutitem\\.h\"", "private", "<QGraphicsLayoutItem>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgraphicslinearlayout\\.h\"", "private", "<QGraphicsLinearLayout>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgraphicsproxywidget\\.h\"", "private", "<QGraphicsProxyWidget>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgraphicsscene\\.h\"", "private", "<QGraphicsScene>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgraphicssceneevent\\.h\"", "private", "<QGraphicsSceneEvent>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgraphicstransform\\.h\"", "private", "<QGraphicsTransform>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgraphicsview\\.h\"", "private", "<QGraphicsView>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgraphicswidget\\.h\"", "private", "<QGraphicsWidget>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgridlayout\\.h\"", "private", "<QGridLayout>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qgroupbox\\.h\"", "private", "<QGroupBox>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qheaderview\\.h\"", "private", "<QHeaderView>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qinputdialog\\.h\"", "private", "<QInputDialog>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qitemdelegate\\.h\"", "private", "<QItemDelegate>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qitemeditorfactory\\.h\"", "private", "<QItemEditorFactory>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qkeyeventtransition\\.h\"", "private", "<QKeyEventTransition>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qkeysequenceedit\\.h\"", "private", "<QKeySequenceEdit>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qlabel\\.h\"", "private", "<QLabel>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qlayout\\.h\"", "private", "<QLayout>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qlayoutitem\\.h\"", "private", "<QLayoutItem>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qlcdnumber\\.h\"", "private", "<QLCDNumber>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qlineedit\\.h\"", "private", "<QLineEdit>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qlistview\\.h\"", "private", "<QListView>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qlistwidget\\.h\"", "private", "<QListWidget>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qmainwindow\\.h\"", "private", "<QMainWindow>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qmdiarea\\.h\"", "private", "<QMdiArea>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qmdisubwindow\\.h\"", "private", "<QMdiSubWindow>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qmenu\\.h\"", "private", "<QMenu>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qmenubar\\.h\"", "private", "<QMenuBar>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qmessagebox\\.h\"", "private", "<QMessageBox>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qmouseeventtransition\\.h\"", "private", "<QMouseEventTransition>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qopenglwidget\\.h\"", "private", "<QOpenGLWidget>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qplaintextedit\\.h\"", "private", "<QPlainTextEdit>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qprogressbar\\.h\"", "private", "<QProgressBar>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qprogressdialog\\.h\"", "private", "<QProgressDialog>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qproxystyle\\.h\"", "private", "<QProxyStyle>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qpushbutton\\.h\"", "private", "<QPushButton>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qradiobutton\\.h\"", "private", "<QRadioButton>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qrubberband\\.h\"", "private", "<QRubberBand>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qscrollarea\\.h\"", "private", "<QScrollArea>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qscrollbar\\.h\"", "private", "<QScrollBar>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qscroller\\.h\"", "private", "<QScroller>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qscrollerproperties\\.h\"", "private", "<QScrollerProperties>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qshortcut\\.h\"", "private", "<QShortcut>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qsizegrip\\.h\"", "private", "<QSizeGrip>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qsizepolicy\\.h\"", "private", "<QSizePolicy>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qslider\\.h\"", "private", "<QSlider>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qspinbox\\.h\"", "private", "<QSpinBox>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qsplashscreen\\.h\"", "private", "<QSplashScreen>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qsplitter\\.h\"", "private", "<QSplitter>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qstackedlayout\\.h\"", "private", "<QStackedLayout>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qstackedwidget\\.h\"", "private", "<QStackedWidget>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qstatusbar\\.h\"", "private", "<QStatusBar>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qstyle\\.h\"", "private", "<QStyle>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qstyleditemdelegate\\.h\"", "private", "<QStyledItemDelegate>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qstylefactory\\.h\"", "private", "<QStyleFactory>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qstyleoption\\.h\"", "private", "<QStyleOption>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qstylepainter\\.h\"", "private", "<QStylePainter>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qstyleplugin\\.h\"", "private", "<QStylePlugin>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qsystemtrayicon\\.h\"", "private", "<QSystemTrayIcon>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qtabbar\\.h\"", "private", "<QTabBar>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qtableview\\.h\"", "private", "<QTableView>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qtablewidget\\.h\"", "private", "<QTableWidget>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qtabwidget\\.h\"", "private", "<QTabWidget>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qtextbrowser\\.h\"", "private", "<QTextBrowser>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qtextedit\\.h\"", "private", "<QTextEdit>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qtoolbar\\.h\"", "private", "<QToolBar>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qtoolbox\\.h\"", "private", "<QToolBox>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qtoolbutton\\.h\"", "private", "<QToolButton>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qtooltip\\.h\"", "private", "<QToolTip>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qtreeview\\.h\"", "private", "<QTreeView>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qtreewidget\\.h\"", "private", "<QTreeWidget>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qtreewidgetitemiterator\\.h\"", "private", "<QTreeWidgetItemIterator>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qtwidgetsversion\\.h\"", "private", "<QtWidgetsVersion>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qundogroup\\.h\"", "private", "<QUndoGroup>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qundostack\\.h\"", "private", "<QUndoStack>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qundoview\\.h\"", "private", "<QUndoView>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qwhatsthis\\.h\"", "private", "<QWhatsThis>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qwidget\\.h\"", "private", "<QWidget>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qwidgetaction\\.h\"", "private", "<QWidgetAction>", "public" ] },
+    { include: [ "@\"(QtWidgets/)?qwizard\\.h\"", "private", "<QWizard>", "public" ] },
+    { include: [ "@\"(QtWinExtras/)?qtwinextrasversion\\.h\"", "private", "<QtWinExtrasVersion>", "public" ] },
+    { include: [ "@\"(QtWinExtras/)?qwinevent\\.h\"", "private", "<QWinEvent>", "public" ] },
+    { include: [ "@\"(QtWinExtras/)?qwinjumplist\\.h\"", "private", "<QWinJumpList>", "public" ] },
+    { include: [ "@\"(QtWinExtras/)?qwinjumplistcategory\\.h\"", "private", "<QWinJumpListCategory>", "public" ] },
+    { include: [ "@\"(QtWinExtras/)?qwinjumplistitem\\.h\"", "private", "<QWinJumpListItem>", "public" ] },
+    { include: [ "@\"(QtWinExtras/)?qwinmime\\.h\"", "private", "<QWinMime>", "public" ] },
+    { include: [ "@\"(QtWinExtras/)?qwintaskbarbutton\\.h\"", "private", "<QWinTaskbarButton>", "public" ] },
+    { include: [ "@\"(QtWinExtras/)?qwintaskbarprogress\\.h\"", "private", "<QWinTaskbarProgress>", "public" ] },
+    { include: [ "@\"(QtWinExtras/)?qwinthumbnailtoolbar\\.h\"", "private", "<QWinThumbnailToolBar>", "public" ] },
+    { include: [ "@\"(QtWinExtras/)?qwinthumbnailtoolbutton\\.h\"", "private", "<QWinThumbnailToolButton>", "public" ] },
+    { include: [ "@\"(QtXml/)?qtxmlversion\\.h\"", "private", "<QtXmlVersion>", "public" ] },
+    { include: [ "@\"(QtXmlPatterns/)?qabstractmessagehandler\\.h\"", "private", "<QAbstractMessageHandler>", "public" ] },
+    { include: [ "@\"(QtXmlPatterns/)?qabstracturiresolver\\.h\"", "private", "<QAbstractUriResolver>", "public" ] },
+    { include: [ "@\"(QtXmlPatterns/)?qabstractxmlnodemodel\\.h\"", "private", "<QAbstractXmlNodeModel>", "public" ] },
+    { include: [ "@\"(QtXmlPatterns/)?qabstractxmlreceiver\\.h\"", "private", "<QAbstractXmlReceiver>", "public" ] },
+    { include: [ "@\"(QtXmlPatterns/)?qsimplexmlnodemodel\\.h\"", "private", "<QSimpleXmlNodeModel>", "public" ] },
+    { include: [ "@\"(QtXmlPatterns/)?qsourcelocation\\.h\"", "private", "<QSourceLocation>", "public" ] },
+    { include: [ "@\"(QtXmlPatterns/)?qtxmlpatternsversion\\.h\"", "private", "<QtXmlPatternsVersion>", "public" ] },
+    { include: [ "@\"(QtXmlPatterns/)?qxmlformatter\\.h\"", "private", "<QXmlFormatter>", "public" ] },
+    { include: [ "@\"(QtXmlPatterns/)?qxmlname\\.h\"", "private", "<QXmlName>", "public" ] },
+    { include: [ "@\"(QtXmlPatterns/)?qxmlnamepool\\.h\"", "private", "<QXmlNamePool>", "public" ] },
+    { include: [ "@\"(QtXmlPatterns/)?qxmlquery\\.h\"", "private", "<QXmlQuery>", "public" ] },
+    { include: [ "@\"(QtXmlPatterns/)?qxmlresultitems\\.h\"", "private", "<QXmlResultItems>", "public" ] },
+    { include: [ "@\"(QtXmlPatterns/)?qxmlschema\\.h\"", "private", "<QXmlSchema>", "public" ] },
+    { include: [ "@\"(QtXmlPatterns/)?qxmlschemavalidator\\.h\"", "private", "<QXmlSchemaValidator>", "public" ] },
+    { include: [ "@\"(QtXmlPatterns/)?qxmlserializer\\.h\"", "private", "<QXmlSerializer>", "public" ] },
+
+# And lastly, things stored in difficult places
+    { include: [ "@\"(QtCore/)?qobjectdefs\\.h\"", "private", "<QObject>", "public" ] },
+    { include: [ "@\"(QtCore/)?qglobal\\.h\"", "private", "<QtGlobal>", "public" ] },
+    { include: [ "@\"(QtCore/)?qnamespace\\.h\"", "private", "<Qt>", "public" ] },
+    { include: [ "@\"(QtCore/)?qlogging\\.h\"", "private", "<QtDebug>", "public" ] }, #qDebug, qWarning, etc
+    { include: [ "@\"(QtCore/)?qalgorithms\\.h\"", "private", "<QAlgorithms>", "public" ] }, #qSort, etc
+    { include: [ "@\"(QtWinExtras/)?qwinfunctions\\.h\"", "private", "<QtWin>", "public" ] },  # for fromHICON
+
+# These ones are just madness. For instance, why with the above do we get
+#    #include "QtCore/qcoreevent.h"      // for QEvent (ptr only), etc
+    { include: [ "@\"(QtCore/)?qcoreevent\\.h\"", "private", "<QEvent>", "public" ] },
+
+# These ones seem spurious
+#include "QtCore/qtypetraits.h"  // for remove_reference<>::type
+#include "QtCore/qsharedpointer_impl.h"            // for swap
+#include "QtCore/qatomic_msvc.h"
+
+]
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 86d1e4c8..3c786868 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -66,7 +66,6 @@ SET(organizer_SRCS
     moapplication.cpp
     profileinputdialog.cpp
     icondelegate.cpp
-    gameinfoimpl.cpp
     csvbuilder.cpp
     savetextasdialog.cpp
     qtgroupingproxy.cpp
@@ -160,7 +159,6 @@ SET(organizer_HDRS
     moapplication.h
     profileinputdialog.h
     icondelegate.h
-    gameinfoimpl.h
     csvbuilder.h
     savetextasdialog.h
     qtgroupingproxy.h
diff --git a/src/SConscript b/src/SConscript
index 194df9aa..6de7cb62 100644
--- a/src/SConscript
+++ b/src/SConscript
@@ -67,7 +67,6 @@ env.Uic(env.Glob('*.ui'))
 
 env.RequireLibraries('uibase', 'shared', 'bsatk', 'esptk')
 
-
 env.AppendUnique(LIBS = [
     'shell32',
     'user32',
@@ -96,6 +95,12 @@ env['CPPPATH'] += [
     '${BOOSTPATH}',
 ]
 
+#########################FUDGE###############################
+env['CPPPATH'] += [
+    '../plugins/gameGamebryo',
+    ]
+#############################################################
+
 env.AppendUnique(CPPDEFINES = [
     '_UNICODE',
     '_CRT_SECURE_NO_WARNINGS',
@@ -118,8 +123,9 @@ env.AppendUnique(LINKFLAGS = [
 
 #  modeltest is optional and it doesn't compile anyway...
 cpp_files = [
-    x for x in Glob('*.cpp')
-        if x.name != 'modeltest.cpp' and x.name != 'aboutdialog.cpp'
+    x for x in env.Glob('*.cpp', source = True)
+        if x.name != 'modeltest.cpp' and x.name != 'aboutdialog.cpp' and \
+           not x.name.startswith('moc_') # I think this is a strange bug
 ]
 
 about_env = env.Clone()
diff --git a/src/bbcode.cpp b/src/bbcode.cpp
index 0f9170d4..56369538 100644
--- a/src/bbcode.cpp
+++ b/src/bbcode.cpp
@@ -21,8 +21,6 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 
 #include <QRegExp>
 #include <map>
-#include <algorithm>
-#include <boost/assign.hpp>
 
 
 namespace BBCode {
@@ -80,7 +78,7 @@ public:
             if (tagName == "color") {
               QString color = tagIter->second.first.cap(1);
               QString content = tagIter->second.first.cap(2);
-              if (color.at(0) == "#") {
+              if (color.at(0) == '#') {
                 return temp.replace(tagIter->second.first, QString("<font style=\"color: %1;\">%2</font>").arg(color, content));
               } else {
                 auto colIter = m_ColorMap.find(color.toLower());
diff --git a/src/browserdialog.cpp b/src/browserdialog.cpp
index c382c112..e5f0f21d 100644
--- a/src/browserdialog.cpp
+++ b/src/browserdialog.cpp
@@ -18,18 +18,16 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "browserdialog.h"
+
 #include "ui_browserdialog.h"
 #include "browserview.h"
-
 #include "messagedialog.h"
 #include "report.h"
 #include "persistentcookiejar.h"
 
-#include "json.h"
-
 #include <utility.h>
-#include <gameinfo.h>
 #include "settings.h"
+
 #include <QNetworkCookieJar>
 #include <QNetworkCookie>
 #include <QMenu>
diff --git a/src/browserview.h b/src/browserview.h
index f8b132b8..6a89752a 100644
--- a/src/browserview.h
+++ b/src/browserview.h
@@ -21,9 +21,11 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #define NEXUSVIEW_H
 
 
+class QEvent;
+class QUrl;
+class QWidget;
 #include <QWebView>
 #include <QWebPage>
-#include <QTabWidget>
 
 /**
  * @brief web view used to display a nexus page
diff --git a/src/categories.cpp b/src/categories.cpp
index 400cc74b..59291a49 100644
--- a/src/categories.cpp
+++ b/src/categories.cpp
@@ -18,9 +18,10 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "categories.h"
+
 #include <utility.h>
 #include <report.h>
-#include <gameinfo.h>
+
 #include <QObject>
 #include <QFile>
 #include <QDir>
@@ -29,7 +30,6 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 
 
 using namespace MOBase;
-using namespace MOShared;
 
 
 CategoryFactory* CategoryFactory::s_Instance = nullptr;
diff --git a/src/directoryrefresher.cpp b/src/directoryrefresher.cpp
index c253f384..f50a717e 100644
--- a/src/directoryrefresher.cpp
+++ b/src/directoryrefresher.cpp
@@ -18,10 +18,13 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "directoryrefresher.h"
+
+#include "iplugingame.h"
 #include "utility.h"
 #include "report.h"
 #include "modinfo.h"
-#include <gameinfo.h>
+
+#include <QApplication>
 #include <QDir>
 #include <QString>
 
@@ -141,7 +144,9 @@ void DirectoryRefresher::refresh()
 
   m_DirectoryStructure = new DirectoryEntry(L"data", nullptr, 0);
 
-  std::wstring dataDirectory = GameInfo::instance().getGameDirectory() + L"\\data";
+  IPluginGame const *game = qApp->property("managed_game").value<IPluginGame const *>();
+
+  std::wstring dataDirectory = QDir::toNativeSeparators(game->dataDirectory().absolutePath()).toStdWString();
   m_DirectoryStructure->addFromOrigin(L"data", dataDirectory, 0);
 
   // TODO what was the point of having the priority in this tuple? the list is already sorted by priority
diff --git a/src/downloadmanager.cpp b/src/downloadmanager.cpp
index 0cc45183..cbc1ba45 100644
--- a/src/downloadmanager.cpp
+++ b/src/downloadmanager.cpp
@@ -18,18 +18,19 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "downloadmanager.h"
+
 #include "nxmurl.h"
 #include "nexusinterface.h"
 #include "nxmaccessmanager.h"
-#include <gameinfo.h>
+#include "iplugingame.h"
 #include <nxmurl.h>
 #include <taskprogressmanager.h>
 #include "utility.h"
-#include "json.h"
 #include "selectiondialog.h"
 #include "bbcode.h"
 #include <utility.h>
 #include <report.h>
+
 #include <QTimer>
 #include <QFileInfo>
 #include <QRegExp>
@@ -38,6 +39,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include <QMessageBox>
 #include <QCoreApplication>
 #include <QTextDocument>
+
 #include <boost/bind.hpp>
 #include <regex>
 
@@ -448,7 +450,7 @@ void DownloadManager::addNXMDownload(const QString &url)
 {
   NXMUrl nxmInfo(url);
 
-  QString managedGame = ToQString(MOShared::GameInfo::instance().getGameShortName());
+  QString managedGame = m_ManagedGame->getGameShortName();
   qDebug("add nxm download: %s", qPrintable(url));
   if (nxmInfo.game().compare(managedGame, Qt::CaseInsensitive) != 0) {
     qDebug("download requested for wrong game (game: %s, url: %s)", qPrintable(managedGame), qPrintable(nxmInfo.game()));
@@ -1242,13 +1244,14 @@ int DownloadManager::startDownloadURLs(const QStringList &urls)
   return m_ActiveDownloads.size() - 1;
 }
 
+/* This doesn't appear to be used by anything
 int DownloadManager::startDownloadNexusFile(int modID, int fileID)
 {
   int newID = m_ActiveDownloads.size();
   addNXMDownload(QString("nxm://%1/mods/%2/files/%3").arg(ToQString(MOShared::GameInfo::instance().getGameName())).arg(modID).arg(fileID));
   return newID;
 }
-
+*/
 QString DownloadManager::downloadPath(int id)
 {
   return getFilePath(id);
@@ -1468,3 +1471,7 @@ void DownloadManager::directoryChanged(const QString&)
   refreshList();
 }
 
+void DownloadManager::managedGameChanged(MOBase::IPluginGame const *managedGame)
+{
+  m_ManagedGame = managedGame;
+}
diff --git a/src/downloadmanager.h b/src/downloadmanager.h
index 57bd592d..54db4648 100644
--- a/src/downloadmanager.h
+++ b/src/downloadmanager.h
@@ -35,6 +35,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include <QFileSystemWatcher>
 #include <QSettings>
 
+namespace MOBase { class IPluginGame; }
 
 class NexusInterface;
 
@@ -328,7 +329,9 @@ public:
 
 
   virtual int startDownloadURLs(const QStringList &urls);
+  /* This doesn't appear to be used anywhere
   virtual int startDownloadNexusFile(int modID, int fileID);
+  */
   virtual QString downloadPath(int id);
 
   /**
@@ -414,6 +417,8 @@ public slots:
 
   void nxmRequestFailed(int modID, int fileID, QVariant userData, int requestID, const QString &errorString);
 
+  void managedGameChanged(MOBase::IPluginGame const *gamePlugin);
+
 private slots:
 
   void downloadProgress(qint64 bytesReceived, qint64 bytesTotal);
@@ -501,6 +506,7 @@ private:
 
   QRegExp m_DateExpression;
 
+  MOBase::IPluginGame const *m_ManagedGame;
 };
 
 
diff --git a/src/executableslist.cpp b/src/executableslist.cpp
index 12e3d7aa..a4511ade 100644
--- a/src/executableslist.cpp
+++ b/src/executableslist.cpp
@@ -18,16 +18,18 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "executableslist.h"
-#include <gameinfo.h>
+
+#include "iplugingame.h"
+#include "utility.h"
+
 #include <QFileInfo>
 #include <QDir>
 #include <QDebug>
-#include "utility.h"
+
 #include <algorithm>
 
 
 using namespace MOBase;
-using namespace MOShared;
 
 
 ExecutablesList::ExecutablesList()
@@ -38,7 +40,7 @@ ExecutablesList::~ExecutablesList()
 {
 }
 
-void ExecutablesList::init(IPluginGame *game)
+void ExecutablesList::init(IPluginGame const *game)
 {
   Q_ASSERT(game != nullptr);
   m_Executables.clear();
diff --git a/src/executableslist.h b/src/executableslist.h
index b4054bcc..3d5ba0ed 100644
--- a/src/executableslist.h
+++ b/src/executableslist.h
@@ -20,13 +20,14 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef EXECUTABLESLIST_H
 #define EXECUTABLESLIST_H
 
+#include "executableinfo.h"
 
 #include <vector>
+
 #include <QFileInfo>
 #include <QMetaType>
-#include <gameinfo.h>
-#include <iplugingame.h>
 
+namespace MOBase { class IPluginGame; }
 
 /*!
  * @brief Information about an executable
@@ -78,7 +79,7 @@ public:
   /**
    * @brief initialise the list with the executables preconfigured for this game
    **/
-  void init(MOBase::IPluginGame *game);
+  void init(MOBase::IPluginGame const *game);
 
   /**
    * @brief find an executable by its name
diff --git a/src/gameinfoimpl.cpp b/src/gameinfoimpl.cpp
deleted file mode 100644
index 98b0fddf..00000000
--- a/src/gameinfoimpl.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
-Copyright (C) 2012 Sebastian Herbord. All rights reserved.
-
-This file is part of Mod Organizer.
-
-Mod Organizer is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-Mod Organizer is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#include "gameinfoimpl.h"
-#include "gameinfo.h"
-#include <utility.h>
-
-#include <QDebug>
-#include <QDir>
-
-
-using namespace MOBase;
-using namespace MOShared;
-
-
-GameInfoImpl::GameInfoImpl()
-{
-}
-
-IGameInfo::Type GameInfoImpl::type() const
-{
-  switch (GameInfo::instance().getType()) {
-    case GameInfo::TYPE_OBLIVION: return IGameInfo::TYPE_OBLIVION;
-    case GameInfo::TYPE_FALLOUT3: return IGameInfo::TYPE_FALLOUT3;
-    case GameInfo::TYPE_FALLOUTNV: return IGameInfo::TYPE_FALLOUTNV;
-    case GameInfo::TYPE_SKYRIM: return IGameInfo::TYPE_SKYRIM;
-    default: throw MyException(QObject::tr("invalid game type %1").arg(GameInfo::instance().getType()));
-  }
-}
-
-
-QString GameInfoImpl::path() const
-{
-  return QDir::fromNativeSeparators(ToQString(GameInfo::instance().getGameDirectory()));
-}
-
-QString GameInfoImpl::binaryName() const
-{
-  return ToQString(GameInfo::instance().getBinaryName());
-}
-
-namespace {
-
-QString GetAppVersion(std::wstring const &app_name)
-{
-  DWORD handle;
-  DWORD info_len = ::GetFileVersionInfoSizeW(app_name.c_str(), &handle);
-  if (info_len == 0) {
-    qDebug("GetFileVersionInfoSizeW Error %d", ::GetLastError());
-    return "";
-  }
-
-  std::vector<char> buff(info_len);
-  if( ! ::GetFileVersionInfoW(app_name.c_str(), handle, info_len, buff.data())) {
-    qDebug("GetFileVersionInfoW Error %d", ::GetLastError());
-    return "";
-  }
-
-  VS_FIXEDFILEINFO *pFileInfo;
-  UINT buf_len;
-  if ( ! ::VerQueryValueW(buff.data(), L"\\", reinterpret_cast<LPVOID *>(&pFileInfo), &buf_len)) {
-    qDebug("VerQueryValueW Error %d", ::GetLastError());
-    return "";
-  }
-  return QString("%1.%2.%3.%4").arg(HIWORD(pFileInfo->dwFileVersionMS))
-                               .arg(LOWORD(pFileInfo->dwFileVersionMS))
-                               .arg(HIWORD(pFileInfo->dwFileVersionLS))
-                               .arg(LOWORD(pFileInfo->dwFileVersionLS));
-}
-
-}
-
-QString GameInfoImpl::version() const
-{
-  std::wstring dir = GameInfo::instance().getGameDirectory();
-  std::wstring exec = GameInfo::instance().getBinaryName();
-  std::wstring target = L"\\\\?\\" + dir + L"\\" + exec;
-  return GetAppVersion(target.c_str());
-}
-
-QString GameInfoImpl::extenderVersion() const
-{
-  std::wstring dir = GameInfo::instance().getGameDirectory();
-  std::wstring exec = GameInfo::instance().getExtenderName();
-  std::wstring target = L"\\\\?\\" + dir + L"\\" + exec;
-  return GetAppVersion(target.c_str());
-}
diff --git a/src/gameinfoimpl.h b/src/gameinfoimpl.h
deleted file mode 100644
index b7ac78c5..00000000
--- a/src/gameinfoimpl.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
-Copyright (C) 2012 Sebastian Herbord. All rights reserved.
-
-This file is part of Mod Organizer.
-
-Mod Organizer is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-Mod Organizer is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
-*/
-
-#ifndef GAMEINFOIMPL_H
-#define GAMEINFOIMPL_H
-
-
-#include <igameinfo.h>
-#include <QString>
-
-
-class GameInfoImpl : public MOBase::IGameInfo
-{
-public:
-  GameInfoImpl();
-
-  virtual Type type() const;
-  virtual QString path() const;
-  virtual QString binaryName() const;
-  virtual QString version() const;
-  virtual QString extenderVersion() const;
-
-};
-
-#endif // GAMEINFOIMPL_H
diff --git a/src/helper.h b/src/helper.h
index 36f10db1..410e2527 100644
--- a/src/helper.h
+++ b/src/helper.h
@@ -21,7 +21,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #define HELPER_H
 
 
-#include <QString>
+#include <string>
 
 
 /**
diff --git a/src/installationmanager.cpp b/src/installationmanager.cpp
index 9fb9bdbb..7b1f3f37 100644
--- a/src/installationmanager.cpp
+++ b/src/installationmanager.cpp
@@ -18,6 +18,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "installationmanager.h"
+
 #include "utility.h"
 #include "report.h"
 #include "categories.h"
@@ -32,9 +33,9 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include "modinfo.h"
 #include <scopeguard.h>
 #include <installationtester.h>
-#include <gameinfo.h>
 #include <utility.h>
 #include <scopeguard.h>
+
 #include <QFileInfo>
 #include <QLibrary>
 #include <QInputDialog>
@@ -42,11 +43,13 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include <QDir>
 #include <QMessageBox>
 #include <QSettings>
-#include <Shellapi.h>
 #include <QPushButton>
 #include <QApplication>
 #include <QDateTime>
 #include <QDirIterator>
+
+#include <Shellapi.h>
+
 #include <boost/assign.hpp>
 #include <boost/scoped_ptr.hpp>
 
diff --git a/src/loadmechanism.cpp b/src/loadmechanism.cpp
index 4d06bea9..47587467 100644
--- a/src/loadmechanism.cpp
+++ b/src/loadmechanism.cpp
@@ -56,7 +56,7 @@ void LoadMechanism::writeHintFile(const QDir &targetDirectory)
 }
 
 
-void LoadMechanism::removeHintFile(QDir &targetDirectory)
+void LoadMechanism::removeHintFile(QDir targetDirectory)
 {
   targetDirectory.remove("mo_path.txt");
 }
@@ -64,7 +64,8 @@ void LoadMechanism::removeHintFile(QDir &targetDirectory)
 
 bool LoadMechanism::isDirectLoadingSupported()
 {
-  IPluginGame *game = qApp->property("managed_game").value<IPluginGame*>();
+  //FIXME: Seriously? isn't there a 'do i need steam' thing?
+  IPluginGame const *game = qApp->property("managed_game").value<IPluginGame const *>();
   if (game->gameName().compare("oblivion", Qt::CaseInsensitive) == 0) {
     // oblivion can be loaded directly if it's not the steam variant
     return !game->gameDirectory().exists("steam_api.dll");
@@ -76,13 +77,11 @@ bool LoadMechanism::isDirectLoadingSupported()
 
 bool LoadMechanism::isScriptExtenderSupported()
 {
-  IPluginGame *game = qApp->property("managed_game").value<IPluginGame*>();
+  IPluginGame const *game = qApp->property("managed_game").value<IPluginGame const *>();
   ScriptExtender *extender = game->feature<ScriptExtender>();
 
   // test if there even is an extender for the managed game and if so whether it's installed
-  return (extender != nullptr)
-      && (game->gameDirectory().exists(extender->name() + "_loader.exe")
-          || game->gameDirectory().exists(extender->name() + "_steam_loader.dll"));
+  return extender != nullptr && extender->isInstalled();
 }
 
 bool LoadMechanism::isProxyDLLSupported()
@@ -92,7 +91,7 @@ bool LoadMechanism::isProxyDLLSupported()
   // plus: the proxy dll hasn't been working for at least the whole 1.12.x versions of MO and
   // noone reported it so why maintain an unused feature?
   return false;
-/*  IPluginGame *game = qApp->property("managed_game").value<IPluginGame*>();
+/*  IPluginGame const *game = qApp->property("managed_game").value<IPluginGame const *>();
   return game->gameDirectory().exists(QString::fromStdWString(AppConfig::proxyDLLTarget()));*/
 }
 
@@ -124,7 +123,7 @@ bool LoadMechanism::hashIdentical(const QString &fileNameLHS, const QString &fil
 void LoadMechanism::deactivateScriptExtender()
 {
   try {
-    IPluginGame *game = qApp->property("managed_game").value<IPluginGame*>();
+    IPluginGame const *game = qApp->property("managed_game").value<IPluginGame const *>();
     ScriptExtender *extender = game->feature<ScriptExtender>();
     if (extender == nullptr) {
       throw MyException(QObject::tr("game doesn't support a script extender"));
@@ -150,7 +149,7 @@ void LoadMechanism::deactivateScriptExtender()
 void LoadMechanism::deactivateProxyDLL()
 {
   try {
-    IPluginGame *game = qApp->property("managed_game").value<IPluginGame*>();
+    IPluginGame const *game = qApp->property("managed_game").value<IPluginGame const *>();
 
     QString targetPath = game->gameDirectory().absoluteFilePath(QString::fromStdWString(AppConfig::proxyDLLTarget()));
 
@@ -179,7 +178,7 @@ void LoadMechanism::deactivateProxyDLL()
 void LoadMechanism::activateScriptExtender()
 {
   try {
-    IPluginGame *game = qApp->property("managed_game").value<IPluginGame*>();
+    IPluginGame const *game = qApp->property("managed_game").value<IPluginGame const *>();
     ScriptExtender *extender = game->feature<ScriptExtender>();
     if (extender == nullptr) {
       throw MyException(QObject::tr("game doesn't support a script extender"));
@@ -219,7 +218,7 @@ void LoadMechanism::activateScriptExtender()
 void LoadMechanism::activateProxyDLL()
 {
   try {
-    IPluginGame *game = qApp->property("managed_game").value<IPluginGame*>();
+    IPluginGame const *game = qApp->property("managed_game").value<IPluginGame const *>();
 
     QString targetPath = game->gameDirectory().absoluteFilePath(QString::fromStdWString(AppConfig::proxyDLLTarget()));
 
diff --git a/src/loadmechanism.h b/src/loadmechanism.h
index 43a8dd6c..c04473ab 100644
--- a/src/loadmechanism.h
+++ b/src/loadmechanism.h
@@ -91,7 +91,7 @@ private:
   void writeHintFile(const QDir &targetDirectory);
 
   // remove the hint file if it exists. does nothing if the file doesn't exist
-  void removeHintFile(QDir &targetDirectory);
+  void removeHintFile(QDir targetDirectory);
 
   // compare the two files by md5-hash, returns true if they are identical
   bool hashIdentical(const QString &fileNameLHS, const QString &fileNameRHS);
diff --git a/src/main.cpp b/src/main.cpp
index 773bfc16..353e7202 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -26,21 +26,16 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <DbgHelp.h>
-#include <cstdarg>
+
 #include <inject.h>
 #include <appconfig.h>
 #include <utility.h>
 #include <scopeguard.h>
-#include <stdexcept>
 #include "mainwindow.h"
 #include <report.h>
 #include "modlist.h"
 #include "profile.h"
 #include "gameinfo.h"
-#include "fallout3info.h"
-#include "falloutnvinfo.h"
-#include "oblivioninfo.h"
-#include "skyriminfo.h"
 #include "spawn.h"
 #include "executableslist.h"
 #include "singleinstance.h"
@@ -51,11 +46,9 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include "moapplication.h"
 #include "tutorialmanager.h"
 #include "nxmaccessmanager.h"
-#include <iostream>
-#include <ShellAPI.h>
 #include <eh.h>
 #include <windows_error.h>
-#include <boost/scoped_array.hpp>
+
 #include <QApplication>
 #include <QPushButton>
 #include <QListWidget>
@@ -77,6 +70,14 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include <QLibraryInfo>
 #include <QSslSocket>
 
+#include <boost/scoped_array.hpp>
+
+#include <ShellAPI.h>
+
+#include <cstdarg>
+#include <iostream>
+#include <stdexcept>
+
 
 #pragma comment(linker, "/manifestDependency:\"name='dlls' processorArchitecture='x86' version='1.0.0.0' type='win32' \"")
 
@@ -86,7 +87,8 @@ using namespace MOShared;
 
 bool createAndMakeWritable(const std::wstring &subPath)
 {
-  QString fullPath = qApp->property("dataPath").toString() + "/" + QString::fromStdWString(subPath);
+  QString const dataPath = qApp->property("dataPath").toString();
+  QString fullPath = dataPath + "/" + QString::fromStdWString(subPath);
 
   if (!QDir(fullPath).exists()) {
     QDir().mkdir(fullPath);
@@ -100,7 +102,7 @@ bool createAndMakeWritable(const std::wstring &subPath)
            "will be made writable for the current user account). You will be asked to run "
            "\"helper.exe\" with administrative rights."),
            QMessageBox::Yes | QMessageBox::Cancel) == QMessageBox::Yes) {
-      if (!Helper::init(GameInfo::instance().getOrganizerDirectory())) {
+      if (!Helper::init(dataPath.toStdWString())) {
         return false;
       }
     } else {
@@ -329,6 +331,124 @@ QString determineProfile(QStringList &arguments, const QSettings &settings)
   return selectedProfileName;
 }
 
+MOBase::IPluginGame *selectGame(QSettings &settings, QDir const &gamePath, MOBase::IPluginGame *game)
+{
+  settings.setValue("gameName", game->gameName());
+  //Sadly, hookdll needs gamePath in order to run. So following code block is
+  //commented out
+  /*if (gamePath == game->gameDirectory()) {
+    settings.remove("gamePath");
+  } else*/ {
+    QString gameDir = gamePath.absolutePath();
+    game->setGamePath(gameDir);
+    settings.setValue("gamePath", QDir::toNativeSeparators(gameDir).toUtf8().constData());
+  }
+  return game; //Woot
+}
+
+
+MOBase::IPluginGame *determineCurrentGame(QString const &moPath, QSettings &settings, PluginContainer const &plugins)
+{
+  //Determine what game we are running where. Be very paranoid in case the
+  //user has done something odd.
+  //If the game name has been set up, use that.
+  QString gameName = settings.value("gameName", "").toString();
+  if (!gameName.isEmpty()) {
+    MOBase::IPluginGame *game = plugins.managedGame(gameName);
+    if (game == nullptr) {
+      reportError(QObject::tr("Plugin to handle %1 no longer installed").arg(gameName));
+      return nullptr;
+    }
+    QString gamePath = QString::fromUtf8(settings.value("gamePath", "").toByteArray());
+    if (gamePath == "") {
+      gamePath = game->gameDirectory().absolutePath();
+    }
+    QDir gameDir(gamePath);
+    if (game->looksValid(gameDir)) {
+      return selectGame(settings, gameDir, game);
+    }
+  }
+
+  //gameName wasn't set, or otherwise can't be found. Try looking through all
+  //the plugins using the gamePath
+  QString gamePath = QString::fromUtf8(settings.value("gamePath", "").toByteArray());
+  if (!gamePath.isEmpty()) {
+    QDir gameDir(gamePath);
+    //Look to see if one of the installed games binary file exists in the current
+    //game directory.
+    for (IPluginGame * const game : plugins.plugins<IPluginGame>()) {
+      if (game->looksValid(gameDir)) {
+        return selectGame(settings, gameDir, game);
+      }
+    }
+  }
+
+  //OK, we are in a new setup or existing info is useless.
+  //See if MO has been installed inside a game directory
+  for (IPluginGame * const game : plugins.plugins<IPluginGame>()) {
+    if (game->isInstalled() && moPath.startsWith(game->gameDirectory().absolutePath())) {
+      //Found it.
+      return selectGame(settings, game->gameDirectory(), game);
+    }
+  }
+
+  //Try walking up the directory tree to see if MO has been installed inside a game
+  {
+    QDir gameDir(moPath);
+    do {
+      //Look to see if one of the installed games binary file exists in the current
+      //directory.
+      for (IPluginGame * const game : plugins.plugins<IPluginGame>()) {
+        if (game->looksValid(gameDir)) {
+          return selectGame(settings, gameDir, game);
+        }
+      }
+      //OK, chop off the last directory and try again
+    } while (gameDir.cdUp());
+  }
+
+  //Then try a selection dialogue.
+  if (!gamePath.isEmpty() || !gameName.isEmpty()) {
+    reportError(QObject::tr("Could not use configuration settings for game \"%1\", path \"%2\".").
+                                                   arg(gameName).arg(gamePath));
+  }
+
+  SelectionDialog selection(QObject::tr("Please select the game to manage"), nullptr, QSize(32, 32));
+
+  for (IPluginGame *game : plugins.plugins<IPluginGame>()) {
+    if (game->isInstalled()) {
+      QString path = game->gameDirectory().absolutePath();
+      selection.addChoice(game->gameIcon(), game->gameName(), path, QVariant::fromValue(game));
+    }
+  }
+
+  selection.addChoice(QString("Browse..."), QString(), QVariant::fromValue(static_cast<IPluginGame *>(nullptr)));
+
+  while (selection.exec() != QDialog::Rejected) {
+    IPluginGame * game = selection.getChoiceData().value<IPluginGame *>();
+    if (game != nullptr) {
+      return selectGame(settings, game->gameDirectory(), game);
+    }
+
+    gamePath = QFileDialog::getExistingDirectory(
+          nullptr, QObject::tr("Please select the game to manage"), QString(),
+          QFileDialog::ShowDirsOnly);
+
+    if (!gamePath.isEmpty()) {
+      QDir gameDir(gamePath);
+      for (IPluginGame * const game : plugins.plugins<IPluginGame>()) {
+        if (game->looksValid(gameDir)) {
+          return selectGame(settings, gameDir, game);
+        }
+      }
+      reportError(QObject::tr("No game identified in \"%1\". The directory is required to contain "
+                              "the game binary and its launcher.").arg(gamePath));
+    }
+  }
+
+  return nullptr;
+}
+
 int main(int argc, char *argv[])
 {
   MOApplication application(argc, argv);
@@ -341,7 +461,7 @@ int main(int argc, char *argv[])
     instanceID = instanceFile.readAll().trimmed();
   }  
 
-  QString dataPath =
+  QString const dataPath =
       instanceID.isEmpty() ? application.applicationDirPath()
                            : QDir::fromNativeSeparators(
                                QStandardPaths::writableLocation(QStandardPaths::DataLocation)
@@ -373,7 +493,7 @@ int main(int argc, char *argv[])
   QSplashScreen splash(pixmap);
 
   try {
-    if (!bootstrap()) { // requires gameinfo to be initialised!
+    if (!bootstrap()) {
       return -1;
     }
 
@@ -442,63 +562,19 @@ int main(int argc, char *argv[])
     PluginContainer pluginContainer(&organizer);
     pluginContainer.loadPlugins();
 
-    QString gamePath = QString::fromUtf8(settings.value("gamePath", "").toByteArray());
-    bool done = false;
-    while (!done) {
-      if (!GameInfo::init(ToWString(application.applicationDirPath()), ToWString(dataPath), ToWString(QDir::toNativeSeparators(gamePath)))) {
-        if (!gamePath.isEmpty()) {
-          reportError(QObject::tr("No game identified in \"%1\". The directory is required to contain "
-                                  "the game binary and its launcher.").arg(gamePath));
-        }
-        SelectionDialog selection(QObject::tr("Please select the game to manage"), nullptr, QSize(32, 32));
-
-        for (const IPluginGame * const game : pluginContainer.plugins<IPluginGame>()) {
-          if (game->isInstalled()) {
-            QString path = game->gameDirectory().absolutePath();
-            selection.addChoice(game->gameIcon(), game->gameName(), path, path);
-          }
-        }
-
-        selection.addChoice(QString("Browse..."), QString(), QString());
-
-        if (selection.exec() == QDialog::Rejected) {
-          gamePath = "";
-          done = true;
-        } else {
-          gamePath = QDir::cleanPath(selection.getChoiceData().toString());
-          if (gamePath.isEmpty()) {
-            gamePath = QFileDialog::getExistingDirectory(
-                  nullptr, QObject::tr("Please select the game to manage"), QString(),
-                  QFileDialog::ShowDirsOnly);
-            qDebug() << "manually selected path " << gamePath;
-          }
-        }
-      } else {
-        done = true;
-        gamePath = ToQString(GameInfo::instance().getGameDirectory());
-      }
-    }
-
-    if (gamePath.isEmpty()) {
-      // game not found and user canceled
-      return -1;
-    } else if (gamePath.length() != 0) {
-      // user selected a folder and game was initialised with it
-      qDebug("game path: %s", qPrintable(gamePath));
-      settings.setValue("gamePath", gamePath.toUtf8().constData());
-    }
-
-    organizer.setManagedGame(ToQString(GameInfo::instance().getGameName()), gamePath);
-
-    organizer.createDefaultProfile();
-
-    if (pluginContainer.managedGame(ToQString(GameInfo::instance().getGameName())) == nullptr) {
-      reportError(QObject::tr("Plugin to handle %1 not installed").arg(ToQString(GameInfo::instance().getGameName())));
+    MOBase::IPluginGame *game = determineCurrentGame(application.applicationDirPath(), settings, pluginContainer);
+    if (game == nullptr) {
       return 1;
     }
 
-    IPluginGame *game = organizer.managedGame();
+    organizer.setManagedGame(game);
 
+    //*sigh just for making it work
+    GameInfo::init(application.applicationDirPath().toStdWString(), game->gameDirectory().absolutePath().toStdWString());
+
+    organizer.createDefaultProfile();
+
+    //See the pragma - we apparently don't use this so not sure why we check it
     if (!settings.contains("game_edition")) {
       QStringList editions = game->gameVariants();
       if (editions.size() > 1) {
@@ -518,7 +594,7 @@ int main(int argc, char *argv[])
 
 
 #pragma message("edition isn't used?")
-    qDebug("managing game at %s", qPrintable(QDir::toNativeSeparators(gamePath)));
+    qDebug("managing game at %s", qPrintable(QDir::toNativeSeparators(game->gameDirectory().absolutePath())));
 
     organizer.updateExecutablesList(settings);
 
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 9982e928..f30e46f1 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -19,6 +19,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "mainwindow.h"
 #include "ui_mainwindow.h"
+
 #include "spawn.h"
 #include "report.h"
 #include "modlist.h"
@@ -52,17 +53,18 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include "credentialsdialog.h"
 #include "selectiondialog.h"
 #include "csvbuilder.h"
-#include "gameinfoimpl.h"
 #include "savetextasdialog.h"
 #include "problemsdialog.h"
 #include "previewdialog.h"
 #include "browserdialog.h"
 #include "aboutdialog.h"
 #include "safewritefile.h"
-#include "organizerproxy.h"
+//?
+//#include "isavegame.h"
+//#include "savegameinfo.h"
+//?
 #include "nxmaccessmanager.h"
 #include <archive.h>
-#include <gameinfo.h>
 #include <appconfig.h>
 #include <utility.h>
 #include <ipluginproxy.h>
@@ -71,15 +73,12 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include <questionboxmemory.h>
 #include <taskprogressmanager.h>
 #include <util.h>
-#include <map>
-#include <ctime>
-#include <wchar.h>
-#include <utility.h>
+#include <scopeguard.h>
+
 #include <QTime>
 #include <QInputDialog>
 #include <QSettings>
 #include <QWhatsThis>
-#include <sstream>
 #include <QProcess>
 #include <QMenu>
 #include <QBuffer>
@@ -101,10 +100,6 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include <QtPlugin>
 #include <QIdentityProxyModel>
 #include <QClipboard>
-#include <Psapi.h>
-#include <shlobj.h>
-#include <ShellAPI.h>
-#include <TlHelp32.h>
 #include <QNetworkInterface>
 #include <QNetworkProxy>
 #include <QJsonDocument>
@@ -119,7 +114,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #endif
 #include <QCoreApplication>
 #include <QProgressDialog>
-#include <scopeguard.h>
+
 #ifndef Q_MOC_RUN
 #include <boost/thread.hpp>
 #include <boost/algorithm/string.hpp>
@@ -127,8 +122,19 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include <boost/foreach.hpp>
 #include <boost/assign.hpp>
 #endif
+
+#include <Psapi.h>
+#include <shlobj.h>
+#include <ShellAPI.h>
+#include <TlHelp32.h>
+
+#include <sstream>
 #include <regex>
 #include <functional>
+#include <map>
+#include <ctime>
+#include <wchar.h>
+#include <utility.h>
 
 #ifdef TEST_MODELS
 #include "modeltest.h"
@@ -154,7 +160,6 @@ MainWindow::MainWindow(const QString &exeName
   , m_ModListGroupingProxy(nullptr)
   , m_ModListSortProxy(nullptr)
   , m_OldExecutableIndex(-1)
-  , m_GamePath(ToQString(GameInfo::instance().getGameDirectory()))
   , m_CategoryFactory(CategoryFactory::instance())
   , m_ContextItem(nullptr)
   , m_ContextAction(nullptr)
@@ -359,7 +364,7 @@ MainWindow::~MainWindow()
 void MainWindow::updateWindowTitle(const QString &accountName, bool premium)
 {
   QString title = QString("%1 Mod Organizer v%2").arg(
-        ToQString(GameInfo::instance().getGameName()),
+        m_OrganizerCore.managedGame()->gameName(),
         m_OrganizerCore.getVersion().displayString());
 
   if (accountName.isEmpty()) {
@@ -827,7 +832,8 @@ void MainWindow::setBrowserGeometry(const QByteArray &geometry)
 
 SaveGameGamebryo *MainWindow::getSaveGame(const QString &name)
 {
-  return new SaveGameGamebryo(this, name);
+  IPluginGame const *game = m_OrganizerCore.managedGame();
+  return new SaveGameGamebryo(this, name, game);
 }
 
 
@@ -1032,9 +1038,9 @@ void MainWindow::on_profileBox_currentIndexChanged(int index)
 
     if (ui->profileBox->currentIndex() == 0) {
       ui->profileBox->setCurrentIndex(previousIndex);
-      ProfilesDialog(ui->profileBox->currentText(), this).exec();
+      ProfilesDialog(ui->profileBox->currentText(), m_OrganizerCore.managedGame(), this).exec();
       while (!refreshProfiles()) {
-        ProfilesDialog(ui->profileBox->currentText(), this).exec();
+        ProfilesDialog(ui->profileBox->currentText(), m_OrganizerCore.managedGame(), this).exec();
       }
     } else {
       activateSelectedProfile();
@@ -1259,9 +1265,11 @@ QDir MainWindow::currentSavesDir() const
     savesDir.setPath(m_OrganizerCore.currentProfile()->absolutePath() + "/saves");
   } else {
     wchar_t path[MAX_PATH];
-    ::GetPrivateProfileStringW(L"General", L"SLocalSavePath", L"Saves",
-                               path, MAX_PATH,
-                               (ToWString(m_OrganizerCore.currentProfile()->absolutePath()) + L"\\" + GameInfo::instance().getIniFileNames().at(0)).c_str());
+    ::GetPrivateProfileStringW(
+          L"General", L"SLocalSavePath", L"Saves",
+          path, MAX_PATH,
+          ToWString(m_OrganizerCore.currentProfile()->absolutePath() + "/" +
+                      m_OrganizerCore.managedGame()->getIniFiles()[0]).c_str());
     savesDir.setPath(m_OrganizerCore.managedGame()->documentsDirectory().absoluteFilePath(QString::fromWCharArray(path)));
   }
 
@@ -1332,8 +1340,7 @@ void MainWindow::updateBSAList(const QStringList &defaultArchives, const QString
 
   std::vector<std::pair<UINT32, QTreeWidgetItem*>> items;
 
-  IPluginGame *gamePlugin = qApp->property("managed_game").value<IPluginGame*>();
-  BSAInvalidation *invalidation = gamePlugin->feature<BSAInvalidation>();
+  BSAInvalidation *invalidation = m_OrganizerCore.managedGame()->feature<BSAInvalidation>();
   std::vector<FileEntry::Ptr> files = m_OrganizerCore.directoryStructure()->getFiles();
 
   QStringList plugins = m_OrganizerCore.findFiles("", [] (const QString &fileName) -> bool {
@@ -1819,16 +1826,18 @@ void MainWindow::on_actionInstallMod_triggered()
 
 void MainWindow::on_actionAdd_Profile_triggered()
 {
-  bool repeat = true;
-  while (repeat) {
-    ProfilesDialog profilesDialog(m_GamePath, this);
+  for (;;) {
+    //Note: Calling this with an invalid profile name. Not quite sure why
+    ProfilesDialog profilesDialog(m_OrganizerCore.managedGame()->gameDirectory().absolutePath(),
+                                  m_OrganizerCore.managedGame(),
+                                  this);
     // workaround: need to disable monitoring of the saves directory, otherwise the active
     // profile directory is locked
     stopMonitorSaves();
     profilesDialog.exec();
     refreshSaveList(); // since the save list may now be outdated we have to refresh it completely
     if (refreshProfiles() && !profilesDialog.failed()) {
-      repeat = false;
+      break;
     }
   }
 //  addProfile();
@@ -2525,7 +2534,7 @@ void MainWindow::visitOnNexus_clicked()
 {
   int modID = m_OrganizerCore.modList()->data(m_OrganizerCore.modList()->index(m_ContextRow, 0), Qt::UserRole).toInt();
   if (modID > 0)  {
-    linkClicked(QString("%1/mods/%2").arg(ToQString(GameInfo::instance().getNexusPage(false))).arg(modID));
+    nexusLinkActivated(NexusInterface::instance()->getModURL(modID));
   } else {
     MessageDialog::showMessage(tr("Nexus ID for this Mod is unknown"), this);
   }
@@ -3111,6 +3120,7 @@ void MainWindow::on_modList_customContextMenuRequested(const QPoint &pos)
             } break;
           }
         }
+
         std::vector<ModInfo::EFlag> flags = info->getFlags();
         if (std::find(flags.begin(), flags.end(), ModInfo::FLAG_INVALID) != flags.end()) {
           menu->addAction(tr("Ignore missing data"), this, SLOT(ignoreMissingData_clicked()));
@@ -3120,9 +3130,9 @@ void MainWindow::on_modList_customContextMenuRequested(const QPoint &pos)
           menu->addAction(tr("Visit on Nexus"), this, SLOT(visitOnNexus_clicked()));
         }
 
+        //If a URL is specified which is not the game's URL, pop up 'visit web page'
         if (info->getURL() != "" &&
-            !GameInfo::instance().isValidModURL(info->getNexusID(),
-                                                info->getURL().toStdWString())) {
+            !NexusInterface::instance()->isModURL(info->getNexusID(), info->getURL())) {
           menu->addAction(tr("Visit web page"), this, SLOT(visitWebPage_clicked()));
         }
 
@@ -3188,7 +3198,7 @@ void MainWindow::deleteSavegame_clicked()
 
   foreach (const QModelIndex &idx, selectedIndexes) {
     QString name = idx.data().toString();
-    SaveGame *save = new SaveGame(this,  idx.data(Qt::UserRole).toString());
+    SaveGame *save = new SaveGame(this,  idx.data(Qt::UserRole).toString(), m_OrganizerCore.managedGame());
 
     if (count < 10) {
       savesMsgLabel += "<li>" + QFileInfo(name).completeBaseName() + "</li>";
@@ -3244,9 +3254,9 @@ void MainWindow::fixMods_clicked()
 
   // search in data
   {
-    QDir dataDir(m_GamePath + "/data");
+    QDir dataDir(m_OrganizerCore.managedGame()->dataDirectory());
     QStringList esps = dataDir.entryList(espFilter);
-    foreach (const QString &esp, esps) {
+    for (const QString &esp : esps) {
       std::map<QString, std::vector<QString> >::iterator iter = missingPlugins.find(esp);
       if (iter != missingPlugins.end()) {
         iter->second.push_back("<data>");
@@ -3260,7 +3270,7 @@ void MainWindow::fixMods_clicked()
     ModInfo::Ptr modInfo = ModInfo::getByIndex(modIndex);
 
     QStringList esps = QDir(modInfo->absolutePath()).entryList(espFilter);
-    foreach (const QString &esp, esps) {
+    for (const QString &esp : esps) {
       std::map<QString, std::vector<QString> >::iterator iter = missingPlugins.find(esp);
       if (iter != missingPlugins.end()) {
         iter->second.push_back(modInfo->name());
@@ -3272,7 +3282,7 @@ void MainWindow::fixMods_clicked()
   {
     QDir overwriteDir(qApp->property("dataPath").toString() + "/" + QString::fromStdWString(AppConfig::overwritePath()));
     QStringList esps = overwriteDir.entryList(espFilter);
-    foreach (const QString &esp, esps) {
+    for (const QString &esp : esps) {
       std::map<QString, std::vector<QString> >::iterator iter = missingPlugins.find(esp);
       if (iter != missingPlugins.end()) {
         iter->second.push_back("<overwrite>");
@@ -3436,7 +3446,9 @@ void MainWindow::on_actionSettings_triggered()
 
 void MainWindow::on_actionNexus_triggered()
 {
-  ::ShellExecuteW(nullptr, L"open", GameInfo::instance().getNexusPage(false).c_str(), nullptr, nullptr, SW_SHOWNORMAL);
+  ::ShellExecuteW(nullptr, L"open",
+                  NexusInterface::instance()->getGameURL().toStdWString().c_str(),
+                  nullptr, nullptr, SW_SHOWNORMAL);
 }
 
 
@@ -3830,9 +3842,11 @@ void MainWindow::on_actionUpdate_triggered()
 void MainWindow::on_actionEndorseMO_triggered()
 {
   if (QMessageBox::question(this, tr("Endorse Mod Organizer"),
-                            tr("Do you want to endorse Mod Organizer on %1 now?").arg(ToQString(GameInfo::instance().getNexusPage())),
+                            tr("Do you want to endorse Mod Organizer on %1 now?").arg(
+                                      NexusInterface::instance()->getGameURL()),
                             QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes) {
-    NexusInterface::instance()->requestToggleEndorsement(GameInfo::instance().getNexusModID(), true, this, QVariant(), QString());
+    NexusInterface::instance()->requestToggleEndorsement(
+          m_OrganizerCore.managedGame()->getNexusModOrganizerID(), true, this, QVariant(), QString());
   }
 }
 
@@ -3896,7 +3910,7 @@ void MainWindow::nxmUpdatesAvailable(const std::vector<int> &modIDs, QVariant us
   QVariantList resultList = resultData.toList();
   for (auto iter = resultList.begin(); iter != resultList.end(); ++iter) {
     QVariantMap result = iter->toMap();
-    if (result["id"].toInt() == GameInfo::instance().getNexusModID()) {
+    if (result["id"].toInt() == m_OrganizerCore.managedGame()->getNexusModOrganizerID()) {
       if (!result["voted_by_user"].toBool()) {
         ui->actionEndorseMO->setVisible(true);
       }
@@ -4412,8 +4426,8 @@ void MainWindow::on_bossButton_clicked()
     parameters << "--unattended"
                << "--stdout"
                << "--noreport"
-               << "--game" << ToQString(GameInfo::instance().getGameShortName())
-               << "--gamePath" << QString("\"%1\"").arg(ToQString(GameInfo::instance().getGameDirectory()))
+               << "--game" << m_OrganizerCore.managedGame()->getGameShortName()
+               << "--gamePath" << QString("\"%1\"").arg(m_OrganizerCore.managedGame()->gameDirectory().absolutePath())
                << "--out" << outPath;
 
     if (m_DidUpdateMasterList) {
@@ -4546,12 +4560,12 @@ void MainWindow::on_bossButton_clicked()
 
     // if the game specifies load order by file time, our own load order file needs to be removed because it's outdated.
     // refreshESPList will then use the file time as the load order.
-    if (GameInfo::instance().getLoadOrderMechanism() == GameInfo::TYPE_FILETIME) {
+    if (m_OrganizerCore.managedGame()->getLoadOrderMechanism() == IPluginGame::LoadOrderMechanism::FileTime) {
       qDebug("removing loadorder.txt");
       QFile::remove(m_OrganizerCore.currentProfile()->getLoadOrderFileName());
     }
     m_OrganizerCore.refreshESPList();
-    if (GameInfo::instance().getLoadOrderMechanism() == GameInfo::TYPE_FILETIME) {
+    if (m_OrganizerCore.managedGame()->getLoadOrderMechanism() == IPluginGame::LoadOrderMechanism::FileTime) {
       // the load order should have been retrieved from file time, now save it to our own format
       m_OrganizerCore.savePluginList();
     }
diff --git a/src/mainwindow.h b/src/mainwindow.h
index 3c7f2258..0cdea807 100644
--- a/src/mainwindow.h
+++ b/src/mainwindow.h
@@ -285,15 +285,11 @@ private:
 
   int m_OldExecutableIndex;
 
-  QString m_GamePath;
-
   int m_ContextRow;
   QPersistentModelIndex m_ContextIdx;
   QTreeWidgetItem *m_ContextItem;
   QAction *m_ContextAction;
 
-  //int m_SelectedSaveGame;
-
   CategoryFactory &m_CategoryFactory;
 
   int m_ModsToUpdate;
diff --git a/src/modinfo.cpp b/src/modinfo.cpp
index fe5098e8..8bc767c5 100644
--- a/src/modinfo.cpp
+++ b/src/modinfo.cpp
@@ -28,10 +28,14 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include "categories.h"
 #include "modinfodialog.h"
 #include "overwriteinfodialog.h"
-#include "json.h"
 #include "filenamestring.h"
 #include "versioninfo.h"
 
+#include <iplugingame.h>
+#include <versioninfo.h>
+#include <appconfig.h>
+#include <scriptextender.h>
+
 #include <QApplication>
 #include <QDirIterator>
 #include <QMutexLocker>
@@ -197,7 +201,10 @@ unsigned int ModInfo::findMod(const boost::function<bool (ModInfo::Ptr)> &filter
 }
 
 
-void ModInfo::updateFromDisc(const QString &modDirectory, DirectoryEntry **directoryStructure, bool displayForeign)
+void ModInfo::updateFromDisc(const QString &modDirectory,
+                             DirectoryEntry **directoryStructure,
+                             bool displayForeign,
+                             MOBase::IPluginGame const *game)
 {
   QMutexLocker lock(&s_Mutex);
   s_Collection.clear();
@@ -213,19 +220,25 @@ void ModInfo::updateFromDisc(const QString &modDirectory, DirectoryEntry **direc
   }
 
   { // list plugins in the data directory and make a foreign-managed mod out of each
-    std::vector<std::wstring> dlcPlugins = GameInfo::instance().getDLCPlugins();
-    QDir dataDir(QDir::fromNativeSeparators(ToQString(GameInfo::instance().getGameDirectory())) + "/data");
-    foreach (const QFileInfo &file, dataDir.entryInfoList(QStringList() << "*.esp" << "*.esm")) {
-      if ((file.baseName() != "Update") // hide update
-          && (file.baseName() != ToQString(GameInfo::instance().getGameName())) // hide the game esp
+    QStringList dlcPlugins = game->getDLCPlugins();
+    QStringList mainPlugins = game->getPrimaryPlugins();
+    QDir dataDir(game->dataDirectory());
+    for (const QString &file : dataDir.entryList({ "*.esp", "*.esm" })) {
+      if (std::find_if(mainPlugins.begin(), mainPlugins.end(),
+                       [&file](QString const &p) {
+                          return p.compare(file, Qt::CaseInsensitive) == 0; }) == mainPlugins.end()
           && (displayForeign // show non-dlc bundles only if the user wants them
-              || std::find(dlcPlugins.begin(), dlcPlugins.end(), ToWString(file.fileName())) != dlcPlugins.end())) {
+              || std::find_if(dlcPlugins.begin(), dlcPlugins.end(),
+                              [&file](QString const &p) {
+                                  return p.compare(file, Qt::CaseInsensitive) == 0; }) != dlcPlugins.end())) {
+
+        QFileInfo f(file); //Just so I can get a basename...
         QStringList archives;
-        foreach (const QString archiveName, dataDir.entryList(QStringList() << file.baseName() + "*.bsa")) {
+        for (const QString &archiveName : dataDir.entryList({ f.baseName() + "*.bsa" })) {
           archives.append(dataDir.absoluteFilePath(archiveName));
         }
 
-        createFromPlugin(file.fileName(), archives, directoryStructure);
+        createFromPlugin(file, archives, directoryStructure);
       }
     }
   }
@@ -275,7 +288,10 @@ int ModInfo::checkAllForUpdate(QObject *receiver)
   int result = 0;
   std::vector<int> modIDs;
 
-  modIDs.push_back(GameInfo::instance().getNexusModID());
+  //I ought to store this, it's used elsewhere
+  IPluginGame const *game = qApp->property("managed_game").value<IPluginGame const *>();
+
+  modIDs.push_back(game->getNexusModOrganizerID());
 
   for (const ModInfo::Ptr &mod : s_Collection) {
     if (mod->canBeUpdated()) {
diff --git a/src/modinfo.h b/src/modinfo.h
index 7d305c11..ae22ccd8 100644
--- a/src/modinfo.h
+++ b/src/modinfo.h
@@ -22,6 +22,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "imodinterface.h"
 #include "versioninfo.h"
+//#include <directoryentry.h>
 
 class QDateTime;
 class QDir;
@@ -36,6 +37,7 @@ class QDir;
 #include <set>
 #include <vector>
 
+namespace MOBase { class IPluginGame; }
 namespace MOShared { class DirectoryEntry; }
 
 /**
@@ -104,7 +106,10 @@ public:
   /**
    * @brief read the mod directory and Mod ModInfo objects for all subdirectories
    **/
-  static void updateFromDisc(const QString &modDirectory, MOShared::DirectoryEntry **directoryStructure, bool displayForeign);
+  static void updateFromDisc(const QString &modDirectory,
+                             MOShared::DirectoryEntry **directoryStructure,
+                             bool displayForeign,
+                             MOBase::IPluginGame const *game);
 
   static void clear() { s_Collection.clear(); s_ModsByName.clear(); s_ModsByModID.clear(); }
 
diff --git a/src/modinfodialog.cpp b/src/modinfodialog.cpp
index 35da228b..feaac2d4 100644
--- a/src/modinfodialog.cpp
+++ b/src/modinfodialog.cpp
@@ -20,6 +20,8 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include "modinfodialog.h"
 #include "ui_modinfodialog.h"
 
+#include "iplugingame.h"
+#include "nexusinterface.h"
 #include "report.h"
 #include "utility.h"
 #include "messagedialog.h"
@@ -27,7 +29,6 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include "questionboxmemory.h"
 #include "settings.h"
 #include "categories.h"
-#include <gameinfo.h>
 
 #include <QDir>
 #include <QDirIterator>
@@ -36,10 +37,12 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include <QMessageBox>
 #include <QMenu>
 #include <QFileSystemModel>
-#include <Shlwapi.h>
-#include <sstream>
 #include <QInputDialog>
 
+#include <Shlwapi.h>
+
+#include <sstream>
+
 
 using namespace MOBase;
 using namespace MOShared;
@@ -688,7 +691,9 @@ void ModInfoDialog::on_visitNexusLabel_linkActivated(const QString &link)
 
 void ModInfoDialog::linkClicked(const QUrl &url)
 {
-  if (url.toString().startsWith(ToQString(GameInfo::instance().getNexusPage(false)))) {
+  //Ideally we'd ask the mod for the game and the web service then pass the game
+  //and URL to the web service
+  if (NexusInterface::instance()->isURLGameRelated(url)) {
     this->close();
     emit nexusLinkActivated(url.toString());
   } else {
@@ -832,12 +837,11 @@ void ModInfoDialog::activateNexusTab()
   QLineEdit *modIDEdit = findChild<QLineEdit*>("modIDEdit");
   int modID = modIDEdit->text().toInt();
   if (modID != 0) {
-    QString nexusLink = QString("%1/downloads/file.php?id=%2").arg(ToQString(GameInfo::instance().getNexusPage(false))).arg(modID);
+    QString nexusLink = NexusInterface::instance()->getModURL(modID);
     QLabel *visitNexusLabel = findChild<QLabel*>("visitNexusLabel");
     visitNexusLabel->setText(tr("<a href=\"%1\">Visit on Nexus</a>").arg(nexusLink));
     visitNexusLabel->setToolTip(nexusLink);
 
-
     if (m_ModInfo->getNexusDescription().isEmpty() ||
         QDateTime::currentDateTime() > m_ModInfo->getLastNexusQuery().addDays(1)) {
       refreshNexusData(modID);
diff --git a/src/modinfoforeign.cpp b/src/modinfoforeign.cpp
index c0e769c9..4dbe034b 100644
--- a/src/modinfoforeign.cpp
+++ b/src/modinfoforeign.cpp
@@ -1,8 +1,10 @@
 #include "modinfoforeign.h"
 
-#include "gameinfo.h"
+#include "iplugingame.h"
 #include "utility.h"
 
+#include <QApplication>
+
 using namespace MOBase;
 using namespace MOShared;
 
@@ -18,7 +20,9 @@ QDateTime ModInfoForeign::creationTime() const
 
 QString ModInfoForeign::absolutePath() const
 {
-  return QDir::fromNativeSeparators(ToQString(GameInfo::instance().getGameDirectory())) + "/data";
+  //I ought to store this, it's used elsewhere
+  IPluginGame const *game = qApp->property("managed_game").value<IPluginGame const *>();
+  return game->dataDirectory().absolutePath();
 }
 
 std::vector<ModInfo::EFlag> ModInfoForeign::getFlags() const
diff --git a/src/modinfoforeign.h b/src/modinfoforeign.h
index b8ff2671..b35c099b 100644
--- a/src/modinfoforeign.h
+++ b/src/modinfoforeign.h
@@ -35,7 +35,7 @@ public:
   virtual QString notes() const { return ""; }
   virtual QDateTime creationTime() const;
   virtual QString absolutePath() const;
-  virtual MOBase::VersionInfo getNewestVersion() const { return ""; }
+  virtual MOBase::VersionInfo getNewestVersion() const { return QString(); }
   virtual QString getInstallationFile() const { return ""; }
   virtual int getNexusID() const { return -1; }
   virtual std::vector<QString> getIniTweaks() const { return std::vector<QString>(); }
diff --git a/src/modinfooverwrite.h b/src/modinfooverwrite.h
index 9184a90c..b6cdfb43 100644
--- a/src/modinfooverwrite.h
+++ b/src/modinfooverwrite.h
@@ -37,7 +37,7 @@ public:
   virtual QString notes() const { return ""; }
   virtual QDateTime creationTime() const { return QDateTime(); }
   virtual QString absolutePath() const;
-  virtual MOBase::VersionInfo getNewestVersion() const { return ""; }
+  virtual MOBase::VersionInfo getNewestVersion() const { return QString(); }
   virtual QString getInstallationFile() const { return ""; }
   virtual int getFixedPriority() const { return INT_MAX; }
   virtual int getNexusID() const { return -1; }
diff --git a/src/modlist.cpp b/src/modlist.cpp
index 197250a3..9d7f32c8 100644
--- a/src/modlist.cpp
+++ b/src/modlist.cpp
@@ -24,15 +24,14 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include "qtgroupingproxy.h"
 #include "viewmarkingscrollbar.h"
 #include "modlistsortproxy.h"
-#include <gameinfo.h>
 #include <appconfig.h>
 #include <utility.h>
 #include <report.h>
+
 #include <QFileInfo>
 #include <QDir>
 #include <QDirIterator>
 #include <QMimeData>
-#include <stdexcept>
 #include <QStandardItemModel>
 #include <QMessageBox>
 #include <QStringList>
@@ -44,7 +43,9 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include <QAbstractItemView>
 #include <QSortFilterProxyModel>
 #include <QApplication>
+
 #include <sstream>
+#include <stdexcept>
 #include <algorithm>
 
 
diff --git a/src/nexusinterface.cpp b/src/nexusinterface.cpp
index 25f3d1b4..26a74ef6 100644
--- a/src/nexusinterface.cpp
+++ b/src/nexusinterface.cpp
@@ -18,14 +18,18 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "nexusinterface.h"
+
+#include "iplugingame.h"
 #include "nxmaccessmanager.h"
 #include "json.h"
 #include "selectiondialog.h"
-#include <QApplication>
 #include <utility.h>
-#include <regex>
 #include <util.h>
 
+#include <QApplication>
+
+#include <regex>
+
 
 using namespace MOBase;
 using namespace MOShared;
@@ -33,34 +37,33 @@ using namespace MOShared;
 
 NexusBridge::NexusBridge(const QString &subModule)
   : m_Interface(NexusInterface::instance())
-  , m_Url() // lazy initialized
   , m_SubModule(subModule)
 {
 }
 
 void NexusBridge::requestDescription(int modID, QVariant userData)
 {
-  m_RequestIDs.insert(m_Interface->requestDescription(modID, this, userData, m_SubModule, url()));
+  m_RequestIDs.insert(m_Interface->requestDescription(modID, this, userData, m_SubModule));
 }
 
 void NexusBridge::requestFiles(int modID, QVariant userData)
 {
-  m_RequestIDs.insert(m_Interface->requestFiles(modID, this, userData, m_SubModule, url()));
+  m_RequestIDs.insert(m_Interface->requestFiles(modID, this, userData, m_SubModule));
 }
 
 void NexusBridge::requestFileInfo(int modID, int fileID, QVariant userData)
 {
-  m_RequestIDs.insert(m_Interface->requestFileInfo(modID, fileID, this, userData, m_SubModule, url()));
+  m_RequestIDs.insert(m_Interface->requestFileInfo(modID, fileID, this, userData, m_SubModule));
 }
 
 void NexusBridge::requestDownloadURL(int modID, int fileID, QVariant userData)
 {
-  m_RequestIDs.insert(m_Interface->requestDownloadURL(modID, fileID, this, userData, m_SubModule, url()));
+  m_RequestIDs.insert(m_Interface->requestDownloadURL(modID, fileID, this, userData, m_SubModule));
 }
 
 void NexusBridge::requestToggleEndorsement(int modID, bool endorse, QVariant userData)
 {
-  m_RequestIDs.insert(m_Interface->requestToggleEndorsement(modID, endorse, this, userData, m_SubModule, url()));
+  m_RequestIDs.insert(m_Interface->requestToggleEndorsement(modID, endorse, this, userData, m_SubModule));
 }
 
 void NexusBridge::nxmDescriptionAvailable(int modID, QVariant userData, QVariant resultData, int requestID)
@@ -136,13 +139,6 @@ void NexusBridge::nxmRequestFailed(int modID, int fileID, QVariant userData, int
   }
 }
 
-QString NexusBridge::url() {
-  if (m_Url.isEmpty()) {
-    m_Url = MOBase::ToQString(MOShared::GameInfo::instance().getNexusInfoUrl());
-  }
-  return m_Url;
-}
-
 
 QAtomicInt NexusInterface::NXMRequestInfo::s_NextID(0);
 
@@ -218,8 +214,8 @@ void NexusInterface::interpretNexusFileName(const QString &fileName, QString &mo
         QString r3Highlight(fileName);
         r3Highlight.insert(result.position(3) + result.length(3), "* ").insert(result.position(3), " *");
 
-        selection.addChoice(candidate.c_str(), r3Highlight, strtol(candidate.c_str(), nullptr, 10));
-        selection.addChoice(candidate2.c_str() + offset, r2Highlight, abs(strtol(candidate2.c_str() + offset, nullptr, 10)));
+        selection.addChoice(candidate.c_str(), r3Highlight, static_cast<int>(strtol(candidate.c_str(), nullptr, 10)));
+        selection.addChoice(candidate2.c_str() + offset, r2Highlight, static_cast<int>(abs(strtol(candidate2.c_str() + offset, nullptr, 10))));
         if (selection.exec() == QDialog::Accepted) {
           modID = selection.getChoiceData().toInt();
         } else {
@@ -245,12 +241,43 @@ void NexusInterface::interpretNexusFileName(const QString &fileName, QString &mo
   }
 }
 
+bool NexusInterface::isURLGameRelated(const QUrl &url) const
+{
+  QString const name(url.toString());
+  return name.startsWith(getGameURL() + "/") ||
+         name.startsWith(getOldModsURL() + "/");
+}
+
+QString NexusInterface::getGameURL() const
+{
+  return "http://www.nexusmods.com/" + m_Game->getGameShortName().toLower();
+}
+
+QString NexusInterface::getOldModsURL() const
+{
+  return "http://" + m_Game->getGameShortName().toLower() + ".nexusmods.com/mods";
+}
+
+
+QString NexusInterface::getModURL(int modID) const
+{
+  return QString("%1/mods/%2").arg(getGameURL()).arg(modID);
+}
+
+bool NexusInterface::isModURL(int modID, QString const &url) const
+{
+  if (url == getModURL(modID)) {
+    return true;
+  }
+  //Try the alternate (old style) mod name
+  QString alt = QString("%1/%2").arg(getOldModsURL()).arg(modID);
+  return alt == url;
+}
 
 int NexusInterface::requestDescription(int modID, QObject *receiver, QVariant userData,
-                                       const QString &subModule, const QString &url, int nexusGameId)
+                                       const QString &subModule, MOBase::IPluginGame const *game)
 {
-  NXMRequestInfo requestInfo(modID, NXMRequestInfo::TYPE_DESCRIPTION, userData, subModule, url,
-                             nexusGameId == -1 ? GameInfo::instance().getNexusGameID() : nexusGameId);
+  NXMRequestInfo requestInfo(modID, NXMRequestInfo::TYPE_DESCRIPTION, userData, subModule, game);
   m_RequestQueue.enqueue(requestInfo);
 
   connect(this, SIGNAL(nxmDescriptionAvailable(int,QVariant,QVariant,int)),
@@ -265,9 +292,9 @@ int NexusInterface::requestDescription(int modID, QObject *receiver, QVariant us
 
 
 int NexusInterface::requestUpdates(const std::vector<int> &modIDs, QObject *receiver, QVariant userData,
-                                   const QString &subModule, const QString &url)
+                                   const QString &subModule, MOBase::IPluginGame const *game)
 {
-  NXMRequestInfo requestInfo(modIDs, NXMRequestInfo::TYPE_GETUPDATES, userData, subModule, url, GameInfo::instance().getNexusGameID());
+  NXMRequestInfo requestInfo(modIDs, NXMRequestInfo::TYPE_GETUPDATES, userData, subModule, game);
   m_RequestQueue.enqueue(requestInfo);
 
   connect(this, SIGNAL(nxmUpdatesAvailable(std::vector<int>,QVariant,QVariant,int)),
@@ -301,9 +328,9 @@ void NexusInterface::fakeFiles()
 
 
 int NexusInterface::requestFiles(int modID, QObject *receiver, QVariant userData,
-                                 const QString &subModule, const QString &url)
+                                 const QString &subModule, MOBase::IPluginGame const *game)
 {
-  NXMRequestInfo requestInfo(modID, NXMRequestInfo::TYPE_FILES, userData, subModule, url, GameInfo::instance().getNexusGameID());
+  NXMRequestInfo requestInfo(modID, NXMRequestInfo::TYPE_FILES, userData, subModule, game);
   m_RequestQueue.enqueue(requestInfo);
   connect(this, SIGNAL(nxmFilesAvailable(int,QVariant,QVariant,int)),
           receiver, SLOT(nxmFilesAvailable(int,QVariant,QVariant,int)), Qt::UniqueConnection);
@@ -321,9 +348,9 @@ int NexusInterface::requestFiles(int modID, QObject *receiver, QVariant userData
 
 
 int NexusInterface::requestFileInfo(int modID, int fileID, QObject *receiver, QVariant userData, const QString &subModule,
-                                    const QString &url)
+                                     MOBase::IPluginGame const *game)
 {
-  NXMRequestInfo requestInfo(modID, fileID, NXMRequestInfo::TYPE_FILEINFO, userData, subModule, url, GameInfo::instance().getNexusGameID());
+  NXMRequestInfo requestInfo(modID, fileID, NXMRequestInfo::TYPE_FILEINFO, userData, subModule, game);
   m_RequestQueue.enqueue(requestInfo);
 
   connect(this, SIGNAL(nxmFileInfoAvailable(int,int,QVariant,QVariant,int)),
@@ -338,9 +365,9 @@ int NexusInterface::requestFileInfo(int modID, int fileID, QObject *receiver, QV
 
 
 int NexusInterface::requestDownloadURL(int modID, int fileID, QObject *receiver, QVariant userData,
-                                       const QString &subModule, const QString &url)
+                                       const QString &subModule, MOBase::IPluginGame const *game)
 {
-  NXMRequestInfo requestInfo(modID, fileID, NXMRequestInfo::TYPE_DOWNLOADURL, userData, subModule, url, GameInfo::instance().getNexusGameID());
+  NXMRequestInfo requestInfo(modID, fileID, NXMRequestInfo::TYPE_DOWNLOADURL, userData, subModule, game);
   m_RequestQueue.enqueue(requestInfo);
 
   connect(this, SIGNAL(nxmDownloadURLsAvailable(int,int,QVariant,QVariant,int)),
@@ -355,9 +382,9 @@ int NexusInterface::requestDownloadURL(int modID, int fileID, QObject *receiver,
 
 
 int NexusInterface::requestToggleEndorsement(int modID, bool endorse, QObject *receiver, QVariant userData,
-                                             const QString &subModule, const QString &url)
+                                             const QString &subModule, MOBase::IPluginGame const *game)
 {
-  NXMRequestInfo requestInfo(modID, NXMRequestInfo::TYPE_TOGGLEENDORSEMENT, userData, subModule, url, GameInfo::instance().getNexusGameID());
+  NXMRequestInfo requestInfo(modID, NXMRequestInfo::TYPE_TOGGLEENDORSEMENT, userData, subModule, game);
   requestInfo.m_Endorse = endorse;
   m_RequestQueue.enqueue(requestInfo);
 
@@ -558,13 +585,24 @@ void NexusInterface::requestTimeout()
   }
 }
 
+void NexusInterface::managedGameChanged(IPluginGame const *game)
+{
+  m_Game = game;
+}
+
+namespace {
+  QString get_management_url(MOBase::IPluginGame const *game)
+  {
+    return "http://nmm.nexusmods.com/" + game->getGameShortName().toLower();
+  }
+}
 
 NexusInterface::NXMRequestInfo::NXMRequestInfo(int modID
                                                , NexusInterface::NXMRequestInfo::Type type
                                                , QVariant userData
                                                , const QString &subModule
-                                               , const QString &url
-                                               , int nexusGameId)
+                                               , MOBase::IPluginGame const *game
+                                               )
   : m_ModID(modID)
   , m_FileID(0)
   , m_Reply(nullptr)
@@ -573,9 +611,9 @@ NexusInterface::NXMRequestInfo::NXMRequestInfo(int modID
   , m_Timeout(nullptr)
   , m_Reroute(false)
   , m_ID(s_NextID.fetchAndAddAcquire(1))
-  , m_URL(url)
+  , m_URL(get_management_url(game))
   , m_SubModule(subModule)
-  , m_NexusGameID(nexusGameId)
+  , m_NexusGameID(game->getNexusGameID())
   , m_Endorse(false)
 {}
 
@@ -583,8 +621,8 @@ NexusInterface::NXMRequestInfo::NXMRequestInfo(std::vector<int> modIDList
                                                , NexusInterface::NXMRequestInfo::Type type
                                                , QVariant userData
                                                , const QString &subModule
-                                               , const QString &url
-                                               , int nexusGameId)
+                                               , MOBase::IPluginGame const *game
+                                               )
   : m_ModID(-1)
   , m_ModIDList(modIDList)
   , m_FileID(0)
@@ -594,9 +632,9 @@ NexusInterface::NXMRequestInfo::NXMRequestInfo(std::vector<int> modIDList
   , m_Timeout(nullptr)
   , m_Reroute(false)
   , m_ID(s_NextID.fetchAndAddAcquire(1))
-  , m_URL(url)
+  , m_URL(get_management_url(game))
   , m_SubModule(subModule)
-  , m_NexusGameID(nexusGameId)
+  , m_NexusGameID(game->getNexusGameID())
   , m_Endorse(false)
 {}
 
@@ -605,8 +643,8 @@ NexusInterface::NXMRequestInfo::NXMRequestInfo(int modID
                                                , NexusInterface::NXMRequestInfo::Type type
                                                , QVariant userData
                                                , const QString &subModule
-                                               , const QString &url
-                                               , int nexusGameId)
+                                               , MOBase::IPluginGame const *game
+                                               )
   : m_ModID(modID)
   , m_FileID(fileID)
   , m_Reply(nullptr)
@@ -615,8 +653,8 @@ NexusInterface::NXMRequestInfo::NXMRequestInfo(int modID
   , m_Timeout(nullptr)
   , m_Reroute(false)
   , m_ID(s_NextID.fetchAndAddAcquire(1))
-  , m_URL(url)
+  , m_URL(get_management_url(game))
   , m_SubModule(subModule)
-  , m_NexusGameID(nexusGameId)
+  , m_NexusGameID(game->getNexusGameID())
   , m_Endorse(false)
 {}
diff --git a/src/nexusinterface.h b/src/nexusinterface.h
index c0ee50cd..c9a81134 100644
--- a/src/nexusinterface.h
+++ b/src/nexusinterface.h
@@ -20,20 +20,20 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef NEXUSINTERFACE_H
 #define NEXUSINTERFACE_H
 
-
-
 #include <utility.h>
-#include <gameinfo.h>
 #include <versioninfo.h>
 #include <imodrepositorybridge.h>
+
 #include <QNetworkReply>
 #include <QNetworkDiskCache>
 #include <QQueue>
 #include <QVariant>
 #include <QTimer>
+
 #include <list>
 #include <set>
 
+namespace MOBase { class IPluginGame; }
 
 class NexusInterface;
 class NXMAccessManager;
@@ -106,14 +106,9 @@ public slots:
   void nxmEndorsementToggled(int modID, QVariant userData, QVariant resultData, int requestID);
   void nxmRequestFailed(int modID, int fileID, QVariant userData, int requestID, const QString &errorMessage);
 
-private:
-
-  QString url();
-
 private:
 
   NexusInterface *m_Interface;
-  QString m_Url;
   QString m_SubModule;
   std::set<int> m_RequestIDs;
 
@@ -147,29 +142,67 @@ public:
    */
   void cleanup();
 
+  /**
+   * @brief request description for a mod
+   *
+   * @param modID id of the mod caller is interested in (assumed to be for the current game)
+   * @param receiver the object to receive the result asynchronously via a signal (nxmDescriptionAvailable)
+   * @param userData user data to be returned with the result
+   * @return int an id to identify the request
+   **/
+  int requestDescription(int modID, QObject *receiver, QVariant userData, const QString &subModule)
+  {
+    return requestDescription(modID, receiver, userData, subModule, m_Game);
+  }
+
   /**
    * @brief request description for a mod
    *
    * @param modID id of the mod caller is interested in
    * @param receiver the object to receive the result asynchronously via a signal (nxmDescriptionAvailable)
    * @param userData user data to be returned with the result
-   * @param url the url to request from
+   * @param game Game with which the mod is associated
    * @return int an id to identify the request
    **/
   int requestDescription(int modID, QObject *receiver, QVariant userData, const QString &subModule,
-                         const QString &url = MOBase::ToQString(MOShared::GameInfo::instance().getNexusInfoUrl()),
-                         int nexusGameId = -1);
+                         MOBase::IPluginGame const *game);
+
+  /**
+   * @brief request nexus descriptions for multiple mods at once
+   * @param modIDs a list of ids of mods the caller is interested in (assumed to be for the current game)
+   * @param receiver the object to receive the result asynchronously via a signal (nxmDescriptionAvailable)
+   * @param userData user data to be returned with the result
+   * @return int an id to identify the request
+   */
+  int requestUpdates(const std::vector<int> &modIDs, QObject *receiver, QVariant userData, const QString &subModule)
+  {
+    return requestUpdates(modIDs, receiver, userData, subModule, m_Game);
+  }
 
   /**
    * @brief request nexus descriptions for multiple mods at once
    * @param modIDs a list of ids of mods the caller is interested in
    * @param receiver the object to receive the result asynchronously via a signal (nxmDescriptionAvailable)
    * @param userData user data to be returned with the result
-   * @param url the url to request from
+   * @param game the game with which the mods are associated
    * @return int an id to identify the request
    */
   int requestUpdates(const std::vector<int> &modIDs, QObject *receiver, QVariant userData, const QString &subModule,
-                     const QString &url = MOBase::ToQString(MOShared::GameInfo::instance().getNexusInfoUrl()));
+                     MOBase::IPluginGame const *game);
+
+  /**
+   * @brief request a list of the files belonging to a mod
+   *
+   * @param modID id of the mod caller is interested in (assumed to be for the current game)
+   * @param receiver the object to receive the result asynchronously via a signal (nxmFilesAvailable)
+   * @param userData user data to be returned with the result
+   * @return int an id to identify the request
+   **/
+  int requestFiles(int modID, QObject *receiver, QVariant userData, const QString &subModule)
+  {
+    return requestFiles(modID, receiver, userData, subModule, m_Game);
+  }
+
 
   /**
    * @brief request a list of the files belonging to a mod
@@ -177,24 +210,52 @@ public:
    * @param modID id of the mod caller is interested in
    * @param receiver the object to receive the result asynchronously via a signal (nxmFilesAvailable)
    * @param userData user data to be returned with the result
-   * @param url the url to request from
+   * @param game the game with which the mods are associated
    * @return int an id to identify the request
    **/
   int requestFiles(int modID, QObject *receiver, QVariant userData, const QString &subModule,
-                   const QString &url = MOBase::ToQString(MOShared::GameInfo::instance().getNexusInfoUrl()));
+                   MOBase::IPluginGame const *game);
 
   /**
    * @brief request info about a single file of a mod
    *
-   * @param modID id of the mod caller is interested in
+   * @param modID id of the mod caller is interested in (assumed to be for the current game)
    * @param fileID id of the file the caller is interested in
    * @param receiver the object to receive the result asynchronously via a signal (nxmFilesAvailable)
    * @param userData user data to be returned with the result
-   * @param url the url to request from
+   * @return int an id to identify the request
+   **/
+  int requestFileInfo(int modID, int fileID, QObject *receiver, QVariant userData, const QString &subModule)
+  {
+    return requestFileInfo(modID, fileID, receiver, userData, subModule, m_Game);
+  }
+
+  /**
+   * @brief request info about a single file of a mod
+   *
+   * @param modID id of the mod caller is interested in (assumed to be for the current game)
+   * @param fileID id of the file the caller is interested in
+   * @param receiver the object to receive the result asynchronously via a signal (nxmFilesAvailable)
+   * @param userData user data to be returned with the result
+   * @param game the game with which the mods are associated
    * @return int an id to identify the request
    **/
   int requestFileInfo(int modID, int fileID, QObject *receiver, QVariant userData, const QString &subModule,
-                      const QString &url = MOBase::ToQString(MOShared::GameInfo::instance().getNexusInfoUrl()));
+                      MOBase::IPluginGame const *game);
+
+  /**
+   * @brief request the download url of a file
+   *
+   * @param modID id of the mod caller is interested in (assumed to be for the current game)
+   * @param fileID id of the file the caller is interested in
+   * @param receiver the object to receive the result asynchronously via a signal (nxmFilesAvailable)
+   * @param userData user data to be returned with the result
+   * @return int an id to identify the request
+   **/
+  int requestDownloadURL(int modID, int fileID, QObject *receiver, QVariant userData, const QString &subModule)
+  {
+    return requestDownloadURL(modID, fileID, receiver, userData, subModule, m_Game);
+  }
 
   /**
    * @brief request the download url of a file
@@ -203,11 +264,23 @@ public:
    * @param fileID id of the file the caller is interested in
    * @param receiver the object to receive the result asynchronously via a signal (nxmFilesAvailable)
    * @param userData user data to be returned with the result
-   * @param url the url to request from
+   * @param game the game with which the mods are associated
    * @return int an id to identify the request
    **/
-  int requestDownloadURL(int modID, int fileID, QObject *receiver, QVariant userData, const QString &subModule,
-                         const QString &url = MOBase::ToQString(MOShared::GameInfo::instance().getNexusInfoUrl()));
+  int requestDownloadURL(int modID, int fileID, QObject *receiver, QVariant userData, const QString &subModule, MOBase::IPluginGame const *game);
+
+  /**
+   * @brief toggle endorsement state of the mod
+   * @param modID id of the mod (assumed to be for the current game)
+   * @param endorse true if the mod should be endorsed, false for un-endorse
+   * @param receiver the object to receive the result asynchronously via a signal (nxmFilesAvailable)
+   * @param userData user data to be returned with the result
+   * @return int an id to identify the request
+   */
+  int requestToggleEndorsement(int modID, bool endorse, QObject *receiver, QVariant userData, const QString &subModule)
+  {
+    return requestToggleEndorsement(modID, endorse, receiver, userData, subModule, m_Game);
+  }
 
   /**
    * @brief toggle endorsement state of the mod
@@ -215,11 +288,11 @@ public:
    * @param endorse true if the mod should be endorsed, false for un-endorse
    * @param receiver the object to receive the result asynchronously via a signal (nxmFilesAvailable)
    * @param userData user data to be returned with the result
-   * @param url the url to request from
+   * @param game the game with which the mods are associated
    * @return int an id to identify the request
    */
   int requestToggleEndorsement(int modID, bool endorse, QObject *receiver, QVariant userData, const QString &subModule,
-                               const QString &url = MOBase::ToQString(MOShared::GameInfo::instance().getNexusInfoUrl()));
+                               MOBase::IPluginGame const *game);
 
   /**
    * @param directory the directory to store cache files
@@ -247,6 +320,39 @@ public:
    */
   static void interpretNexusFileName(const QString &fileName, QString &modName, int &modID, bool query);
 
+  /**
+   * @brief get the currently managed game
+   */
+  MOBase::IPluginGame const *managedGame() const;
+
+  /**
+   * @brief see if the passed URL is related to the current game
+   *
+   * Arguably, this should optionally take a gameplugin pointer
+   */
+  bool isURLGameRelated(QUrl const &url) const;
+
+  /**
+   * @brief Get the nexus page for the current game
+   *
+   * Arguably, this should optionally take a gameplugin pointer
+   */
+  QString getGameURL() const;
+
+  /**
+   * @brief Get the URL for the mod web page
+   * @param modID
+   */
+  QString getModURL(int modID) const;
+
+  /**
+   * @brief Checks if the specified URL might correspond to a nexus mod
+   * @param modID
+   * @param url
+   * @return
+   */
+  bool isModURL(int modID, QString const &url) const;
+
 signals:
 
   void requestNXMDownload(const QString &url);
@@ -261,6 +367,9 @@ signals:
   void nxmEndorsementToggled(int modID, QVariant userData, QVariant resultData, int requestID);
   void nxmRequestFailed(int modID, int fileID, QVariant userData, int requestID, const QString &errorString);
 
+public slots:
+  void managedGameChanged(MOBase::IPluginGame const *game);
+
 private slots:
 
   void requestFinished();
@@ -295,9 +404,9 @@ private:
     int m_ID;
     int m_Endorse;
 
-    NXMRequestInfo(int modID, Type type, QVariant userData, const QString &subModule, const QString &url, int nexusGameId);
-    NXMRequestInfo(std::vector<int> modIDList, Type type, QVariant userData, const QString &subModule, const QString &url, int nexusGameId);
-    NXMRequestInfo(int modID, int fileID, Type type, QVariant userData, const QString &subModule, const QString &url, int nexusGameId);
+    NXMRequestInfo(int modID, Type type, QVariant userData, const QString &subModule, MOBase::IPluginGame const *game);
+    NXMRequestInfo(std::vector<int> modIDList, Type type, QVariant userData, const QString &subModule, MOBase::IPluginGame const *game);
+    NXMRequestInfo(int modID, int fileID, Type type, QVariant userData, const QString &subModule, MOBase::IPluginGame const *game);
 
   private:
     static QAtomicInt s_NextID;
@@ -311,6 +420,7 @@ private:
   void nextRequest();
   void requestFinished(std::list<NXMRequestInfo>::iterator iter);
   bool requiresLogin(const NXMRequestInfo &info);
+  QString getOldModsURL() const;
 
 private:
 
@@ -324,6 +434,8 @@ private:
   MOBase::VersionInfo m_MOVersion;
   QString m_NMMVersion;
 
+  MOBase::IPluginGame const *m_Game;
+
 };
 
 #endif // NEXUSINTERFACE_H
diff --git a/src/nxmaccessmanager.cpp b/src/nxmaccessmanager.cpp
index 0763bb71..7d0dacc2 100644
--- a/src/nxmaccessmanager.cpp
+++ b/src/nxmaccessmanager.cpp
@@ -18,6 +18,8 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "nxmaccessmanager.h"
+
+#include "iplugingame.h"
 #include "nxmurl.h"
 #include "report.h"
 #include "utility.h"
@@ -25,7 +27,6 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include "persistentcookiejar.h"
 #include "settings.h"
 #include <gameinfo.h>
-#include <json.h>
 #include <QMessageBox>
 #include <QPushButton>
 #include <QNetworkProxy>
@@ -39,10 +40,11 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include <QJsonDocument>
 #include <QJsonArray>
 
-
 using namespace MOBase;
-using namespace MOShared;
 
+namespace {
+  QString const Nexus_Management_URL("http://nmm.nexusmods.com");
+}
 
 // unfortunately Nexus doesn't seem to document these states, all I know is all these listed
 // are considered premium (27 should be lifetime premium)
@@ -96,8 +98,7 @@ QNetworkReply *NXMAccessManager::createRequest(
 
 void NXMAccessManager::showCookies() const
 {
-  QUrl url(ToQString(GameInfo::instance().getNexusPage()) + "/");
-
+  QUrl url(Nexus_Management_URL + "/");
   for (const QNetworkCookie &cookie : cookieJar()->cookiesForUrl(url)) {
     qDebug("%s - %s (expires: %s)",
            cookie.name().constData(), cookie.value().constData(),
@@ -110,7 +111,7 @@ void NXMAccessManager::startLoginCheck()
 {
   if (hasLoginCookies()) {
     qDebug("validating login cookies");
-    QNetworkRequest request(ToQString(GameInfo::instance().getNexusPage()) + "/Sessions/?Validate");
+    QNetworkRequest request(Nexus_Management_URL + "/Sessions/?Validate");
     request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
     request.setRawHeader("User-Agent", userAgent().toUtf8());
 
@@ -127,9 +128,8 @@ void NXMAccessManager::startLoginCheck()
 void NXMAccessManager::retrieveCredentials()
 {
   qDebug("retrieving credentials");
-  QNetworkRequest request(ToQString(GameInfo::instance().getNexusPage())
-                          + QString("/Core/Libs/Flamework/Entities/User?GetCredentials&game_id=%1"
-                                    ).arg(GameInfo::instance().getNexusGameID()));
+
+  QNetworkRequest request(Nexus_Management_URL + "/Core/Libs/Flamework/Entities/User?GetCredentials");
   request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
   request.setRawHeader("User-Agent", userAgent().toUtf8());
 
@@ -224,8 +224,9 @@ QString NXMAccessManager::userAgent(const QString &subModule) const
 void NXMAccessManager::pageLogin()
 {
   qDebug("logging %s in on Nexus", qPrintable(m_Username));
-  QString requestString = (ToQString(GameInfo::instance().getNexusPage()) + "/Sessions/?Login&uri=%1")
-                             .arg(QString(QUrl::toPercentEncoding(ToQString(GameInfo::instance().getNexusPage()))));
+
+  QString requestString = (Nexus_Management_URL + "/Sessions/?Login&uri=%1")
+                            .arg(QString(QUrl::toPercentEncoding(Nexus_Management_URL)));
 
   QNetworkRequest request(requestString);
   request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
@@ -289,15 +290,14 @@ void NXMAccessManager::loginError(QNetworkReply::NetworkError)
 
 bool NXMAccessManager::hasLoginCookies() const
 {
-  bool sidCookie = false;
-  QUrl url(ToQString(GameInfo::instance().getNexusPage()) + "/");
+  QUrl url(Nexus_Management_URL + "/");
   QList<QNetworkCookie> cookies = cookieJar()->cookiesForUrl(url);
   for (const QNetworkCookie &cookie : cookies) {
     if (cookie.name() == "sid") {
-      sidCookie = true;
+      return true;
     }
   }
-  return sidCookie;
+  return false;
 }
 
 
@@ -338,4 +338,3 @@ void NXMAccessManager::loginChecked()
   m_LoginReply->deleteLater();
   m_LoginReply = nullptr;
 }
-
diff --git a/src/nxmaccessmanager.h b/src/nxmaccessmanager.h
index a03dbe36..82bd2bd5 100644
--- a/src/nxmaccessmanager.h
+++ b/src/nxmaccessmanager.h
@@ -27,6 +27,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include <QProgressDialog>
 #include <set>
 
+namespace MOBase { class IPluginGame; }
 
 /**
  * @brief access manager extended to handle nxm links
@@ -84,8 +85,6 @@ private slots:
   void loginError(QNetworkReply::NetworkError errorCode);
   void loginTimeout();
 
-public slots:
-
 protected:
 
   virtual QNetworkReply *createRequest(
diff --git a/src/organizer.pro b/src/organizer.pro
index adc606fb..1284aa40 100644
--- a/src/organizer.pro
+++ b/src/organizer.pro
@@ -70,7 +70,6 @@ SOURCES += \
     moapplication.cpp \
     profileinputdialog.cpp \
     icondelegate.cpp \
-    gameinfoimpl.cpp \
     csvbuilder.cpp \
     savetextasdialog.cpp \
     qtgroupingproxy.cpp \
@@ -150,7 +149,6 @@ HEADERS  += \
     moapplication.h \
     profileinputdialog.h \
     icondelegate.h \
-    gameinfoimpl.h \
     csvbuilder.h \
     savetextasdialog.h \
     qtgroupingproxy.h \
@@ -244,6 +242,10 @@ INCLUDEPATH += "E:/Visual Leak Detector/include"
 LIBS += -L"E:/Visual Leak Detector/lib/Win32"
 #DEFINES += LEAK_CHECK_WITH_VLD
 
+#########################FUDGE###############################
+INCLUDEPATH += ../plugins/gameGamebryo
+#############################################################
+
 # custom leak detection
 #LIBS += -lDbgHelp
 
@@ -365,10 +367,10 @@ CONFIG(debug, debug|release) {
 }
 
 OTHER_FILES += \
-    SConscript
+    SConscript \
+    CMakeLists.txt
 
 DISTFILES += \
     tutorials/tutorial_primer_main.js \
     tutorials/Tooltip.qml \
-    tutorials/TooltipArea.qml \
-    SConscript
+    tutorials/TooltipArea.qml
diff --git a/src/organizercore.cpp b/src/organizercore.cpp
index a9284e97..06a6dba4 100644
--- a/src/organizercore.cpp
+++ b/src/organizercore.cpp
@@ -1,6 +1,7 @@
 #include "organizercore.h"
+
+#include "iplugingame.h"
 #include "mainwindow.h"
-#include "gameinfoimpl.h"
 #include "messagedialog.h"
 #include "logbuffer.h"
 #include "credentialsdialog.h"
@@ -19,11 +20,14 @@
 #include <appconfig.h>
 #include <report.h>
 #include <questionboxmemory.h>
+
 #include <QNetworkInterface>
 #include <QMessageBox>
 #include <QDialogButtonBox>
 #include <QApplication>
+
 #include <Psapi.h>
+
 #include <functional>
 
 
@@ -118,8 +122,7 @@ QStringList toStringList(InputIterator current, InputIterator end)
 
 
 OrganizerCore::OrganizerCore(const QSettings &initSettings)
-  : m_GameInfo(new GameInfoImpl())
-  , m_UserInterface(nullptr)
+  : m_UserInterface(nullptr)
   , m_PluginContainer(nullptr)
   , m_GameName()
   , m_CurrentProfile(nullptr)
@@ -159,7 +162,11 @@ OrganizerCore::OrganizerCore(const QSettings &initSettings)
   connect(NexusInterface::instance()->getAccessManager(), SIGNAL(loginSuccessful(bool)), this, SLOT(loginSuccessful(bool)));
   connect(NexusInterface::instance()->getAccessManager(), SIGNAL(loginFailed(QString)), this, SLOT(loginFailed(QString)));
 
-  connect(this, SIGNAL(managedGameChanged(MOBase::IPluginGame*)), &m_Settings, SLOT(managedGameChanged(MOBase::IPluginGame*)));
+  //This seems awfully imperative
+  connect(this, SIGNAL(managedGameChanged(MOBase::IPluginGame const *)), &m_Settings, SLOT(managedGameChanged(MOBase::IPluginGame const *)));
+  connect(this, SIGNAL(managedGameChanged(MOBase::IPluginGame const *)), &m_DownloadManager, SLOT(managedGameChanged(MOBase::IPluginGame const *)));
+  connect(this, SIGNAL(managedGameChanged(MOBase::IPluginGame const *)), &m_PluginList, SLOT(managedGameChanged(MOBase::IPluginGame const *)));
+  connect(this, SIGNAL(managedGameChanged(MOBase::IPluginGame const *)), NexusInterface::instance(), SLOT(managedGameChanged(MOBase::IPluginGame const *)));
 
   connect(&m_PluginList, &PluginList::writePluginsList, &m_PluginListsWriter, &DelayedFileWriterBase::write);
 
@@ -186,7 +193,6 @@ OrganizerCore::~OrganizerCore()
   m_ModList.setProfile(nullptr);
   NexusInterface::instance()->cleanup();
 
-  delete m_GameInfo;
   delete m_DirectoryStructure;
 }
 
@@ -322,7 +328,7 @@ void OrganizerCore::updateExecutablesList(QSettings &settings)
     return;
   }
 
-  m_ExecutablesList.init(m_PluginContainer->managedGame(ToQString(GameInfo::instance().getGameName())));
+  m_ExecutablesList.init(managedGame());
 
   qDebug("setting up configured executables");
 
@@ -350,7 +356,7 @@ void OrganizerCore::updateExecutablesList(QSettings &settings)
   settings.endArray();
 
   // TODO this has nothing to do with executables list move to an appropriate function!
-  ModInfo::updateFromDisc(m_Settings.getModDirectory(), &m_DirectoryStructure, m_Settings.displayForeign());
+  ModInfo::updateFromDisc(m_Settings.getModDirectory(), &m_DirectoryStructure, m_Settings.displayForeign(), managedGame());
 }
 
 void OrganizerCore::setUserInterface(IUserInterface *userInterface, QWidget *widget)
@@ -393,6 +399,14 @@ void OrganizerCore::connectPlugins(PluginContainer *container)
     m_GamePlugin = m_PluginContainer->managedGame(m_GameName);
     emit managedGameChanged(m_GamePlugin);
   }
+  //Do this the hard way
+  for (const IPluginGame * const game : container->plugins<IPluginGame>()) {
+    QString n = game->getGameShortName();
+    if (game->getGameShortName() == "Skyrim") {
+      m_Updater.setNexusDownload(game);
+      break;
+    }
+  }
 }
 
 void OrganizerCore::disconnectPlugins()
@@ -408,15 +422,12 @@ void OrganizerCore::disconnectPlugins()
   m_PluginContainer = nullptr;
 }
 
-void OrganizerCore::setManagedGame(const QString &gameName, const QString &gamePath)
+void OrganizerCore::setManagedGame(MOBase::IPluginGame const *game)
 {
-  m_GameName = gameName;
-  if (m_PluginContainer != nullptr) {
-    m_GamePlugin = m_PluginContainer->managedGame(m_GameName);
-    m_GamePlugin->setGamePath(gamePath);
-    qApp->setProperty("managed_game", QVariant::fromValue(m_GamePlugin));
-    emit managedGameChanged(m_GamePlugin);
-  }
+  m_GameName = game->gameName();
+  m_GamePlugin = game;
+  qApp->setProperty("managed_game", QVariant::fromValue(m_GamePlugin));
+  emit managedGameChanged(m_GamePlugin);
 }
 
 Settings &OrganizerCore::settings()
@@ -555,11 +566,6 @@ void OrganizerCore::setCurrentProfile(const QString &profileName)
   refreshDirectoryStructure();
 }
 
-MOBase::IGameInfo &OrganizerCore::gameInfo() const
-{
-  return *m_GameInfo;
-}
-
 MOBase::IModRepositoryBridge *OrganizerCore::createNexusBridge() const
 {
   return new NexusBridge();
@@ -593,14 +599,10 @@ MOBase::VersionInfo OrganizerCore::appVersion() const
   return m_Updater.getVersion();
 }
 
-MOBase::IModInterface *OrganizerCore::getMod(const QString &name)
+MOBase::IModInterface *OrganizerCore::getMod(const QString &name) const
 {
   unsigned int index = ModInfo::getIndex(name);
-  if (index == UINT_MAX) {
-    return nullptr;
-  } else {
-    return ModInfo::getByIndex(index).data();
-  }
+  return index == UINT_MAX ? nullptr : ModInfo::getByIndex(index).data();
 }
 
 MOBase::IModInterface *OrganizerCore::createMod(GuessedValue<QString> &name)
@@ -930,12 +932,12 @@ void OrganizerCore::spawnBinary(const QFileInfo &binary, const QString &argument
       refreshDirectoryStructure();
       // need to remove our stored load order because it may be outdated if a foreign tool changed the
       // file time. After removing that file, refreshESPList will use the file time as the order
-      if (GameInfo::instance().getLoadOrderMechanism() == GameInfo::TYPE_FILETIME) {
+      if (managedGame()->getLoadOrderMechanism() == IPluginGame::LoadOrderMechanism::FileTime) {
         qDebug("removing loadorder.txt");
         QFile::remove(m_CurrentProfile->getLoadOrderFileName());
       }
       refreshESPList();
-      if (GameInfo::instance().getLoadOrderMechanism() == GameInfo::TYPE_FILETIME) {
+      if (managedGame()->getLoadOrderMechanism() == IPluginGame::LoadOrderMechanism::FileTime) {
         // the load order should have been retrieved from file time, now save it to our own format
         savePluginList();
       }
@@ -961,7 +963,10 @@ HANDLE OrganizerCore::spawnBinaryDirect(const QFileInfo &binary, const QString &
     ::SetEnvironmentVariableW(L"SteamAPPId", ToWString(m_Settings.getSteamAppID()).c_str());
   }
 
-  if ((GameInfo::instance().requiresSteam())
+
+  //This could possibly be extracted somewhere else but it's probably for when
+  //we have more than one provider of game registration.
+  if (QFileInfo(managedGame()->gameDirectory().absoluteFilePath("steam_api.dll")).exists()
       && (m_Settings.getLoadMechanism() == LoadMechanism::LOAD_MODORGANIZER)) {
     if (!testForSteam()) {
       QWidget *window = qApp->activeWindow();
@@ -1017,7 +1022,7 @@ HANDLE OrganizerCore::startApplication(const QString &executable, const QStringL
     binary = QFileInfo(executable);
     if (binary.isRelative()) {
       // relative path, should be relative to game directory
-      binary = QFileInfo(QDir::fromNativeSeparators(ToQString(GameInfo::instance().getGameDirectory())) + "/" + executable);
+      binary = QFileInfo(managedGame()->gameDirectory().absoluteFilePath(executable));
     }
     if (cwd.length() == 0) {
       currentDirectory = binary.absolutePath();
@@ -1133,7 +1138,7 @@ void OrganizerCore::refreshModList(bool saveChanges)
   if (saveChanges) {
     m_CurrentProfile->modlistWriter().writeImmediately(true);
   }
-  ModInfo::updateFromDisc(m_Settings.getModDirectory(), &m_DirectoryStructure, m_Settings.displayForeign());
+  ModInfo::updateFromDisc(m_Settings.getModDirectory(), &m_DirectoryStructure, m_Settings.displayForeign(), managedGame());
 
   m_CurrentProfile->refreshModStatus();
 
@@ -1314,7 +1319,7 @@ PluginListSortProxy *OrganizerCore::createPluginListProxyModel()
   return result;
 }
 
-IPluginGame *OrganizerCore::managedGame() const
+IPluginGame const *OrganizerCore::managedGame() const
 {
   return m_GamePlugin;
 }
@@ -1375,7 +1380,7 @@ void OrganizerCore::directory_refreshed()
 void OrganizerCore::profileRefresh()
 {
   // have to refresh mods twice (again in refreshModList), otherwise the refresh isn't complete. Not sure why
-  ModInfo::updateFromDisc(m_Settings.getModDirectory(), &m_DirectoryStructure, m_Settings.displayForeign());
+  ModInfo::updateFromDisc(m_Settings.getModDirectory(), &m_DirectoryStructure, m_Settings.displayForeign(), managedGame());
   m_CurrentProfile->refreshModStatus();
 
   refreshModList();
@@ -1571,10 +1576,10 @@ void OrganizerCore::prepareStart() {
   storeSettings();
 }
 
+/*
 std::vector<std::pair<QString, QString>> OrganizerCore::fileMapping()
 {
-  IPluginGame *game = qApp->property("managed_game").value<IPluginGame*>();
-  return fileMapping(game->dataDirectory().absolutePath(),
+  return fileMapping(managedGame()->dataDirectory().absolutePath(),
                      directoryStructure(),
                      directoryStructure());
 }
@@ -1610,4 +1615,4 @@ std::vector<std::pair<QString, QString>> OrganizerCore::fileMapping(
   return result;
 }
 
-
+*/
diff --git a/src/organizercore.h b/src/organizercore.h
index 85f0e0c4..5cfbaca4 100644
--- a/src/organizercore.h
+++ b/src/organizercore.h
@@ -73,7 +73,7 @@ public:
   void connectPlugins(PluginContainer *container);
   void disconnectPlugins();
 
-  void setManagedGame(const QString &gameName, const QString &gamePath);
+  void setManagedGame(const MOBase::IPluginGame *game);
 
   void updateExecutablesList(QSettings &settings);
 
@@ -99,7 +99,7 @@ public:
   ModListSortProxy *createModListProxyModel();
   PluginListSortProxy *createPluginListProxyModel();
 
-  MOBase::IPluginGame *managedGame() const;
+  MOBase::IPluginGame const *managedGame() const;
 
   bool isArchivesInit() const { return m_ArchivesInit; }
 
@@ -126,13 +126,12 @@ public:
   MOBase::DelayedFileWriter &pluginsWriter() { return m_PluginListsWriter; }
 
 public:
-  MOBase::IGameInfo &gameInfo() const;
   MOBase::IModRepositoryBridge *createNexusBridge() const;
   QString profileName() const;
   QString profilePath() const;
   QString downloadsPath() const;
   MOBase::VersionInfo appVersion() const;
-  MOBase::IModInterface *getMod(const QString &name);
+  MOBase::IModInterface *getMod(const QString &name) const;
   MOBase::IModInterface *createMod(MOBase::GuessedValue<QString> &name);
   bool removeMod(MOBase::IModInterface *mod);
   void modDataChanged(MOBase::IModInterface *mod);
@@ -157,7 +156,7 @@ public:
   bool onFinishedRun(const std::function<void (const QString &, unsigned int)> &func);
   void refreshModList(bool saveChanges = true);
 
-  std::vector<std::pair<QString, QString> > fileMapping();
+  //std::vector<std::pair<QString, QString> > fileMapping();
 
 public: // IPluginDiagnose interface
 
@@ -194,7 +193,7 @@ signals:
    */
   void modInstalled(const QString &modName);
 
-  void managedGameChanged(MOBase::IPluginGame *gamePlugin);
+  void managedGameChanged(MOBase::IPluginGame const *gamePlugin);
 
 private:
 
@@ -210,9 +209,11 @@ private:
 
   bool testForSteam();
 
-  std::vector<std::pair<QString, QString>> fileMapping(const QString &dataPath,
+  /*
+   * std::vector<std::pair<QString, QString>> fileMapping(const QString &dataPath,
                                                        const MOShared::DirectoryEntry *base,
                                                        const MOShared::DirectoryEntry *directoryEntry);
+*/
 
 private slots:
 
@@ -229,12 +230,10 @@ private:
 
 private:
 
-  MOBase::IGameInfo *m_GameInfo;
-
   IUserInterface *m_UserInterface;
   PluginContainer *m_PluginContainer;
   QString m_GameName;
-  MOBase::IPluginGame *m_GamePlugin;
+  MOBase::IPluginGame const *m_GamePlugin;
 
   Profile *m_CurrentProfile;
 
diff --git a/src/organizerproxy.cpp b/src/organizerproxy.cpp
index 095cb0bb..ba07c154 100644
--- a/src/organizerproxy.cpp
+++ b/src/organizerproxy.cpp
@@ -1,7 +1,8 @@
 #include "organizerproxy.h"
-#include <gameinfo.h>
+
 #include <appconfig.h>
 
+#include <QApplication>
 
 using namespace MOBase;
 using namespace MOShared;
@@ -13,11 +14,6 @@ OrganizerProxy::OrganizerProxy(OrganizerCore *organizer, const QString &pluginNa
 {
 }
 
-IGameInfo &OrganizerProxy::gameInfo() const
-{
-  return m_Proxied->gameInfo();
-}
-
 IModRepositoryBridge *OrganizerProxy::createNexusBridge() const
 {
   return new NexusBridge(m_PluginName);
@@ -40,7 +36,7 @@ QString OrganizerProxy::downloadsPath() const
 
 QString OrganizerProxy::overwritePath() const
 {
-  return QDir::fromNativeSeparators(ToQString(GameInfo::instance().getOrganizerDirectory()))
+  return QDir::fromNativeSeparators(qApp->property("dataPath").toString())
          + "/"
          + ToQString(AppConfig::overwritePath());
 }
@@ -50,7 +46,7 @@ VersionInfo OrganizerProxy::appVersion() const
   return m_Proxied->appVersion();
 }
 
-IModInterface *OrganizerProxy::getMod(const QString &name)
+IModInterface *OrganizerProxy::getMod(const QString &name) const
 {
   return m_Proxied->getMod(name);
 }
@@ -155,17 +151,22 @@ QList<MOBase::IOrganizer::FileInfo> OrganizerProxy::findFileInfos(const QString
   return m_Proxied->findFileInfos(path, filter);
 }
 
-MOBase::IDownloadManager *OrganizerProxy::downloadManager()
+MOBase::IDownloadManager *OrganizerProxy::downloadManager() const
 {
   return m_Proxied->downloadManager();
 }
 
-MOBase::IPluginList *OrganizerProxy::pluginList()
+MOBase::IPluginList *OrganizerProxy::pluginList() const
 {
   return m_Proxied->pluginList();
 }
 
-MOBase::IModList *OrganizerProxy::modList()
+MOBase::IModList *OrganizerProxy::modList() const
 {
   return m_Proxied->modList();
 }
+
+MOBase::IPluginGame const *OrganizerProxy::managedGame() const
+{
+  return m_Proxied->managedGame();
+}
diff --git a/src/organizerproxy.h b/src/organizerproxy.h
index fb502a7f..62a35498 100644
--- a/src/organizerproxy.h
+++ b/src/organizerproxy.h
@@ -12,14 +12,13 @@ public:
 
   OrganizerProxy(OrganizerCore *organizer, const QString &pluginName);
 
-  virtual MOBase::IGameInfo &gameInfo() const;
   virtual MOBase::IModRepositoryBridge *createNexusBridge() const;
   virtual QString profileName() const;
   virtual QString profilePath() const;
   virtual QString downloadsPath() const;
   virtual QString overwritePath() const;
   virtual MOBase::VersionInfo appVersion() const;
-  virtual MOBase::IModInterface *getMod(const QString &name);
+  virtual MOBase::IModInterface *getMod(const QString &name) const;
   virtual MOBase::IModInterface *createMod(MOBase::GuessedValue<QString> &name);
   virtual bool removeMod(MOBase::IModInterface *mod);
   virtual void modDataChanged(MOBase::IModInterface *mod);
@@ -35,9 +34,9 @@ public:
   virtual QStringList getFileOrigins(const QString &fileName) const;
   virtual QList<FileInfo> findFileInfos(const QString &path, const std::function<bool(const FileInfo&)> &filter) const;
 
-  virtual MOBase::IDownloadManager *downloadManager();
-  virtual MOBase::IPluginList *pluginList();
-  virtual MOBase::IModList *modList();
+  virtual MOBase::IDownloadManager *downloadManager() const;
+  virtual MOBase::IPluginList *pluginList() const;
+  virtual MOBase::IModList *modList() const;
   virtual HANDLE startApplication(const QString &executable, const QStringList &args = QStringList(), const QString &cwd = "", const QString &profile = "");
   virtual bool waitForApplication(HANDLE handle, LPDWORD exitCode = nullptr) const;
   virtual void refreshModList(bool saveChanges);
@@ -46,6 +45,7 @@ public:
   virtual bool onFinishedRun(const std::function<void (const QString&, unsigned int)> &func);
   virtual bool onModInstalled(const std::function<void (const QString&)> &func);
 
+  virtual MOBase::IPluginGame const *managedGame() const;
 
 private:
 
diff --git a/src/pluginlist.cpp b/src/pluginlist.cpp
index e7d493a7..7a609374 100644
--- a/src/pluginlist.cpp
+++ b/src/pluginlist.cpp
@@ -24,7 +24,6 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include "scopeguard.h"
 #include "modinfo.h"
 #include <utility.h>
-#include <gameinfo.h>
 #include <iplugingame.h>
 #include <espfile.h>
 #include <report.h>
@@ -128,7 +127,7 @@ void PluginList::refresh(const QString &profileName
   m_ESPsByPriority.clear();
   m_ESPs.clear();
 
-  QStringList primaryPlugins = qApp->property("managed_game").value<IPluginGame*>()->getPrimaryPlugins();
+  QStringList primaryPlugins = m_GamePlugin->getPrimaryPlugins();
 
   m_CurrentProfile = profileName;
 
@@ -313,7 +312,7 @@ bool PluginList::readLoadOrder(const QString &fileName)
 
   int priority = 0;
 
-  QStringList primaryPlugins = qApp->property("managed_game").value<IPluginGame*>()->getPrimaryPlugins();
+  QStringList primaryPlugins = m_GamePlugin->getPrimaryPlugins();
   for (const QString &plugin : primaryPlugins) {
     if (availableESPs.find(plugin) != availableESPs.end()) {
       m_ESPLoadOrder[plugin] = priority++;
@@ -504,7 +503,7 @@ void PluginList::saveTo(const QString &pluginFileName
 
 bool PluginList::saveLoadOrder(DirectoryEntry &directoryStructure)
 {
-  if (GameInfo::instance().getLoadOrderMechanism() != GameInfo::TYPE_FILETIME) {
+  if (m_GamePlugin->getLoadOrderMechanism() != IPluginGame::LoadOrderMechanism::FileTime) {
     // nothing to do
     return true;
   }
@@ -1210,3 +1209,8 @@ PluginList::ESPInfo::ESPInfo(const QString &name, bool enabled,
     m_IsDummy = false;
   }
 }
+
+void PluginList::managedGameChanged(IPluginGame const *gamePlugin)
+{
+  m_GamePlugin = gamePlugin;
+}
diff --git a/src/pluginlist.h b/src/pluginlist.h
index f8972f05..9fe6eeac 100644
--- a/src/pluginlist.h
+++ b/src/pluginlist.h
@@ -22,16 +22,20 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 
 #include <directoryentry.h>
 #include <ipluginlist.h>
+namespace MOBase { class IPluginGame; }
+
 #include <QString>
 #include <QListWidget>
 #include <QTimer>
 #include <QTemporaryFile>
+
 #pragma warning(push)
 #pragma warning(disable: 4100)
 #ifndef Q_MOC_RUN
 #include <boost/signals2.hpp>
 #include <boost/ptr_container/ptr_vector.hpp>
 #endif
+
 #include <vector>
 #include <map>
 
@@ -253,6 +257,12 @@ public slots:
    **/
   void disableAll();
 
+  /**
+   * @brief The currently managed game has changed
+   * @param gamePlugin
+   */
+  void managedGameChanged(MOBase::IPluginGame const *gamePlugin);
+
 signals:
 
  /**
@@ -337,6 +347,8 @@ private:
 
   QTemporaryFile m_TempFile;
 
+  MOBase::IPluginGame const *m_GamePlugin;
+
 };
 
 #pragma warning(pop)
diff --git a/src/profile.cpp b/src/profile.cpp
index b990fbc1..77f6ebd1 100644
--- a/src/profile.cpp
+++ b/src/profile.cpp
@@ -18,7 +18,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "profile.h"
-#include "gameinfo.h"
+
 #include "windows_error.h"
 #include "modinfo.h"
 #include "safewritefile.h"
@@ -30,26 +30,22 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include <report.h>
 #include <bsainvalidation.h>
 #include <dataarchives.h>
+
 #include <QMessageBox>
 #include <QApplication>
 #include <QSettings>
 #include <QTemporaryFile>
+
 #include <functional>
+#include <stdexcept>
 
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <shlobj.h>
-#include <stdexcept>
 
 using namespace MOBase;
 using namespace MOShared;
 
-
-Profile::Profile()
-  : m_ModListWriter(std::bind(&Profile::writeModlistNow, this))
-{
-}
-
 void Profile::touchFile(QString fileName)
 {
   QFile modList(m_Directory.filePath(fileName));
@@ -58,7 +54,7 @@ void Profile::touchFile(QString fileName)
   }
 }
 
-Profile::Profile(const QString &name, IPluginGame *gamePlugin, bool useDefaultSettings)
+Profile::Profile(const QString &name, IPluginGame const *gamePlugin, bool useDefaultSettings)
   : m_ModListWriter(std::bind(&Profile::writeModlistNow, this))
   , m_GamePlugin(gamePlugin)
 {
@@ -99,8 +95,9 @@ Profile::Profile(const QString &name, IPluginGame *gamePlugin, bool useDefaultSe
 }
 
 
-Profile::Profile(const QDir &directory, IPluginGame *gamePlugin)
+Profile::Profile(const QDir &directory, IPluginGame const *gamePlugin)
   : m_Directory(directory)
+  , m_GamePlugin(gamePlugin)
   , m_ModListWriter(std::bind(&Profile::writeModlistNow, this))
 {
   assert(gamePlugin != nullptr);
@@ -125,6 +122,8 @@ Profile::Profile(const QDir &directory, IPluginGame *gamePlugin)
 Profile::Profile(const Profile &reference)
   : m_Directory(reference.m_Directory)
   , m_ModListWriter(std::bind(&Profile::writeModlistNow, this))
+  , m_GamePlugin(reference.m_GamePlugin)
+
 {
   refreshModStatus();
 }
@@ -486,7 +485,7 @@ void Profile::setModPriority(unsigned int index, int &newPriority)
   m_ModListWriter.write();
 }
 
-Profile *Profile::createPtrFrom(const QString &name, const Profile &reference, MOBase::IPluginGame *gamePlugin)
+Profile *Profile::createPtrFrom(const QString &name, const Profile &reference, MOBase::IPluginGame const *gamePlugin)
 {
   QString profileDirectory = qApp->property("dataPath").toString() + "/" + QString::fromStdWString(AppConfig::profilesPath()) + "/" + name;
   reference.copyFilesTo(profileDirectory);
@@ -568,10 +567,8 @@ void Profile::mergeTweaks(ModInfo::Ptr modInfo, const QString &tweakedIni) const
 
 bool Profile::invalidationActive(bool *supported) const
 {
-  IPluginGame *gamePlugin = qApp->property("managed_game").value<IPluginGame*>();
-
-  BSAInvalidation *invalidation = gamePlugin->feature<BSAInvalidation>();
-  DataArchives *dataArchives = gamePlugin->feature<DataArchives>();
+  BSAInvalidation *invalidation = m_GamePlugin->feature<BSAInvalidation>();
+  DataArchives *dataArchives = m_GamePlugin->feature<DataArchives>();
 
   if ((invalidation != nullptr) && (dataArchives != nullptr)) {
     if (supported != nullptr) {
@@ -593,9 +590,7 @@ bool Profile::invalidationActive(bool *supported) const
 
 void Profile::deactivateInvalidation()
 {
-  IPluginGame *gamePlugin = qApp->property("managed_game").value<IPluginGame*>();
-
-  BSAInvalidation *invalidation = gamePlugin->feature<BSAInvalidation>();
+  BSAInvalidation *invalidation = m_GamePlugin->feature<BSAInvalidation>();
 
   if (invalidation != nullptr) {
     invalidation->deactivate(this);
@@ -605,9 +600,7 @@ void Profile::deactivateInvalidation()
 
 void Profile::activateInvalidation()
 {
-  IPluginGame *gamePlugin = qApp->property("managed_game").value<IPluginGame*>();
-
-  BSAInvalidation *invalidation = gamePlugin->feature<BSAInvalidation>();
+  BSAInvalidation *invalidation = m_GamePlugin->feature<BSAInvalidation>();
 
   if (invalidation != nullptr) {
     invalidation->activate(this);
@@ -681,8 +674,7 @@ QString Profile::getDeleterFileName() const
 
 QString Profile::getIniFileName() const
 {
-  std::wstring primaryIniFile = *(GameInfo::instance().getIniFileNames().begin());
-  return m_Directory.absoluteFilePath(ToQString(primaryIniFile));
+  return m_Directory.absoluteFilePath(m_GamePlugin->getIniFiles()[0]);
 }
 
 QString Profile::getProfileTweaks() const
diff --git a/src/profile.h b/src/profile.h
index 342b6fa0..b306e0c5 100644
--- a/src/profile.h
+++ b/src/profile.h
@@ -24,17 +24,16 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include "modinfo.h"
 #include <iprofile.h>
 #include <delayedfilewriter.h>
+
 #include <QString>
 #include <QDir>
-#include <QMetaType>
 #include <QSettings>
+
 #include <vector>
 #include <tuple>
 
 
-namespace MOBase {
-  class IPluginGame;
-}
+namespace MOBase { class IPluginGame; }
 
 /**
  * @brief represents a profile
@@ -50,12 +49,6 @@ public:
 
 public:
 
-  /**
-   * @brief default constructor
-   * @todo This constructor initialised nothing, the resulting object is not usable
-   **/
-  Profile();
-
   /**
    * @brief constructor
    *
@@ -64,7 +57,8 @@ public:
    * @param name name of the new profile
    * @param filter save game filter. Defaults to &lt;no filter&gt;.
    **/
-  Profile(const QString &name, MOBase::IPluginGame *gamePlugin, bool useDefaultSettings);
+  Profile(const QString &name, MOBase::IPluginGame const *gamePlugin, bool useDefaultSettings);
+
   /**
    * @brief constructor
    *
@@ -73,7 +67,7 @@ public:
    * invoking this should always produce a working profile
    * @param directory directory to read the profile from
    **/
-  Profile(const QDir &directory, MOBase::IPluginGame *gamePlugin);
+  Profile(const QDir &directory, MOBase::IPluginGame const *gamePlugin);
 
   Profile(const Profile &reference);
 
@@ -88,7 +82,7 @@ public:
    * @param name of the new profile
    * @param reference profile to copy from
    **/
-  static Profile *createPtrFrom(const QString &name, const Profile &reference, MOBase::IPluginGame *gamePlugin);
+  static Profile *createPtrFrom(const QString &name, const Profile &reference, MOBase::IPluginGame const *gamePlugin);
 
   MOBase::DelayedFileWriter &modlistWriter() { return m_ModListWriter; }
 
@@ -308,7 +302,7 @@ private:
 
   QDir m_Directory;
 
-  MOBase::IPluginGame *m_GamePlugin;
+  MOBase::IPluginGame const * const m_GamePlugin;
 
   mutable QByteArray m_LastModlistHash;
   std::vector<ModStatus> m_ModStatus;
@@ -319,7 +313,5 @@ private:
 
 };
 
-Q_DECLARE_METATYPE(Profile)
-
 
 #endif // PROFILE_H
diff --git a/src/profilesdialog.cpp b/src/profilesdialog.cpp
index 58be5448..b21aee53 100644
--- a/src/profilesdialog.cpp
+++ b/src/profilesdialog.cpp
@@ -42,10 +42,11 @@ using namespace MOShared;
 Q_DECLARE_METATYPE(Profile::Ptr)
 
 
-ProfilesDialog::ProfilesDialog(const QString &profileName, QWidget *parent)
+ProfilesDialog::ProfilesDialog(const QString &profileName, MOBase::IPluginGame const *game, QWidget *parent)
   : TutorableDialog("Profiles", parent)
   , ui(new Ui::ProfilesDialog)
   , m_FailState(false)
+  , m_Game(game)
 {
   ui->setupUi(this);
 
@@ -65,7 +66,6 @@ ProfilesDialog::ProfilesDialog(const QString &profileName, QWidget *parent)
 
   QCheckBox *invalidationBox = findChild<QCheckBox*>("invalidationBox");
 
-  IPluginGame *game = qApp->property("managed_game").value<IPluginGame*>();
   BSAInvalidation *invalidation = game->feature<BSAInvalidation>();
 
   if (invalidation == nullptr) {
@@ -104,7 +104,7 @@ QListWidgetItem *ProfilesDialog::addItem(const QString &name)
   QDir profileDir(name);
   QListWidgetItem *newItem = new QListWidgetItem(profileDir.dirName(), m_ProfilesList);
   try {
-    newItem->setData(Qt::UserRole, QVariant::fromValue(Profile::Ptr(new Profile(profileDir, qApp->property("managed_game").value<IPluginGame*>()))));
+    newItem->setData(Qt::UserRole, QVariant::fromValue(Profile::Ptr(new Profile(profileDir, m_Game))));
     m_FailState = false;
   } catch (const std::exception& e) {
     reportError(tr("failed to create profile: %1").arg(e.what()));
@@ -117,7 +117,7 @@ void ProfilesDialog::createProfile(const QString &name, bool useDefaultSettings)
   try {
     QListWidget *profilesList = findChild<QListWidget*>("profilesList");
     QListWidgetItem *newItem = new QListWidgetItem(name, profilesList);
-    newItem->setData(Qt::UserRole, QVariant::fromValue(Profile::Ptr(new Profile(name, qApp->property("managed_game").value<IPluginGame*>(), useDefaultSettings))));
+    newItem->setData(Qt::UserRole, QVariant::fromValue(Profile::Ptr(new Profile(name, m_Game, useDefaultSettings))));
     profilesList->addItem(newItem);
     m_FailState = false;
   } catch (const std::exception&) {
@@ -131,7 +131,7 @@ void ProfilesDialog::createProfile(const QString &name, const Profile &reference
   try {
     QListWidget *profilesList = findChild<QListWidget*>("profilesList");
     QListWidgetItem *newItem = new QListWidgetItem(name, profilesList);
-    newItem->setData(Qt::UserRole, QVariant::fromValue(Profile::Ptr(Profile::createPtrFrom(name, reference, qApp->property("managed_game").value<IPluginGame*>()))));
+    newItem->setData(Qt::UserRole, QVariant::fromValue(Profile::Ptr(Profile::createPtrFrom(name, reference, m_Game))));
     profilesList->addItem(newItem);
     m_FailState = false;
   } catch (const std::exception&) {
@@ -324,6 +324,6 @@ void ProfilesDialog::on_localSavesBox_stateChanged(int state)
 void ProfilesDialog::on_transferButton_clicked()
 {
   const Profile::Ptr currentProfile = m_ProfilesList->currentItem()->data(Qt::UserRole).value<Profile::Ptr>();
-  TransferSavesDialog transferDialog(*currentProfile, qApp->property("managed_game").value<IPluginGame*>(), this);
+  TransferSavesDialog transferDialog(*currentProfile, m_Game, this);
   transferDialog.exec();
 }
diff --git a/src/profilesdialog.h b/src/profilesdialog.h
index 6dd0c1d4..26476883 100644
--- a/src/profilesdialog.h
+++ b/src/profilesdialog.h
@@ -50,7 +50,7 @@ public:
   * @param parent parent widget
   * @todo the game path could be retrieved from GameInfo just as easily
   **/
- explicit ProfilesDialog(const QString &profileName, QWidget *parent = 0);
+ explicit ProfilesDialog(const QString &profileName, MOBase::IPluginGame const *game, QWidget *parent = 0);
   ~ProfilesDialog();
 
   /**
@@ -93,7 +93,7 @@ private:
   Ui::ProfilesDialog *ui;
   QListWidget *m_ProfilesList;
   bool m_FailState;
-
+  MOBase::IPluginGame const *m_Game;
 };
 
 #endif // PROFILESDIALOG_H
diff --git a/src/savegame.cpp b/src/savegame.cpp
index 1cdabb2d..2b125575 100644
--- a/src/savegame.cpp
+++ b/src/savegame.cpp
@@ -18,50 +18,28 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "savegame.h"
-#include <QFile>
-#include <QBuffer>
-#include <set>
-#include <QFileInfo>
+
+#include "iplugingame.h"
+#include "scriptextender.h"
+#include "utility.h"
+
+#include <QApplication>
 #include <QDateTime>
-#include <utility.h>
+#include <QFile>
+#include <QFileInfo>
+
 #include <limits>
-#include "gameinfo.h"
+#include <set>
 
+using namespace MOBase;
 
-SaveGame::SaveGame(QObject *parent)
-  : QObject(parent), m_FileName(), m_PCName(), m_PCLevel(0), m_PCLocation(), m_SaveNumber(0), m_Screenshot()
+SaveGame::SaveGame(QObject *parent, const QString &filename, const MOBase::IPluginGame *game)
+  : QObject(parent)
+  , m_FileName(filename)
+  , m_Game(game)
 {
 }
 
-
-SaveGame::SaveGame(QObject *parent, const QString &filename)
-  : QObject(parent), m_FileName(filename), m_PCName(), m_PCLevel(0), m_PCLocation(), m_SaveNumber(0), m_Screenshot()
-{
-}
-
-
-SaveGame::SaveGame(const SaveGame& reference)
-  : m_FileName(reference.m_FileName), m_PCName(reference.m_PCName), m_PCLevel(reference.m_PCLevel),
-    m_PCLocation(reference.m_PCLocation), m_SaveNumber(reference.m_SaveNumber),
-    m_Screenshot(reference.m_Screenshot)
-{
-}
-
-
-SaveGame& SaveGame::operator=(const SaveGame &reference)
-{
-  if (&reference != this) {
-    m_FileName = reference.m_FileName;
-    m_PCName = reference.m_PCName;
-    m_PCLevel = reference.m_PCLevel;
-    m_PCLocation = reference.m_PCLocation;
-    m_SaveNumber = reference.m_SaveNumber;
-    m_Screenshot = reference.m_Screenshot;
-  }
-  return *this;
-}
-
-
 SaveGame::~SaveGame()
 {
 }
@@ -69,11 +47,14 @@ SaveGame::~SaveGame()
 QStringList SaveGame::attachedFiles() const
 {
   QStringList result;
-  foreach (const std::wstring &ext, MOShared::GameInfo::instance().getSavegameAttachmentExtensions()) {
-    QFileInfo fi(fileName());
-    fi.setFile(fi.canonicalPath() + "/" + fi.completeBaseName() + "." + MOBase::ToQString(ext));
-    if (fi.exists()) {
-      result.append(fi.filePath());
+  ScriptExtender const *extender = m_Game->feature<ScriptExtender>();
+  if (extender != nullptr) {
+    for (QString const &ext : extender->saveGameAttachmentExtensions()) {
+      QFileInfo fi(fileName());
+      fi.setFile(fi.canonicalPath() + "/" + fi.completeBaseName() + "." + ext);
+      if (fi.exists()) {
+        result.append(fi.filePath());
+      }
     }
   }
 
@@ -86,21 +67,3 @@ QStringList SaveGame::saveFiles() const
   result.append(fileName());
   return result;
 }
-
-
-void SaveGame::setCreationTime(const QString &fileName)
-{
-  QFileInfo creationTime(fileName);
-  QDateTime modified = creationTime.lastModified();
-  memset(&m_CreationTime, 0, sizeof(SYSTEMTIME));
-
-  m_CreationTime.wDay = static_cast<WORD>(modified.date().day());
-  m_CreationTime.wDayOfWeek = static_cast<WORD>(modified.date().dayOfWeek());
-  m_CreationTime.wMonth = static_cast<WORD>(modified.date().month());
-  m_CreationTime.wYear =static_cast<WORD>( modified.date().year());
-
-  m_CreationTime.wHour = static_cast<WORD>(modified.time().hour());
-  m_CreationTime.wMinute = static_cast<WORD>(modified.time().minute());
-  m_CreationTime.wSecond = static_cast<WORD>(modified.time().second());
-  m_CreationTime.wMilliseconds = static_cast<WORD>(modified.time().msec());
-}
diff --git a/src/savegame.h b/src/savegame.h
index 1fd2f7ab..d1bf4691 100644
--- a/src/savegame.h
+++ b/src/savegame.h
@@ -31,6 +31,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
 
+namespace MOBase { class IPluginGame; }
 
 /**
  * @brief represents a single save game
@@ -41,23 +42,14 @@ Q_OBJECT
 
 public:
 
-  /**
-   * @brief construct an empty object
-   **/
-  SaveGame(QObject *parent = 0);
-
   /**
    * @brief construct a save game and immediately read out information from the file
    *
    * @param filename absolute path of the save game file
    **/
-  SaveGame(QObject *parent, const QString &filename);
+  SaveGame(QObject *parent, const QString &filename, MOBase::IPluginGame const *game);
 
-  SaveGame(const SaveGame& reference);
-
-  SaveGame& operator=(const SaveGame &reference);
-
-  ~SaveGame();
+  virtual ~SaveGame();
 
   /**
    * @brief read out information from a savegame
@@ -111,10 +103,6 @@ public:
    **/
   const QImage &screenshot() const { return m_Screenshot; }
 
-private:
-
-  void setCreationTime(const QString &fileName);
-
 protected:
 
   QString m_FileName;
@@ -125,6 +113,8 @@ protected:
   SYSTEMTIME m_CreationTime;
   QImage m_Screenshot;
 
+private:
+  MOBase::IPluginGame const * const m_Game;
 };
 
 
diff --git a/src/savegamegamebryo.cpp b/src/savegamegamebryo.cpp
index 7b012e22..68ed30af 100644
--- a/src/savegamegamebryo.cpp
+++ b/src/savegamegamebryo.cpp
@@ -18,321 +18,49 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "savegamegamebyro.h"
-#include "gameinfo.h"
-#include <QFile>
-#include <QBuffer>
-#include <set>
-#include <QFileInfo>
-#include <QDateTime>
+
+#include "isavegame.h"
+#include "savegameinfo.h"
+#include "iplugingame.h"
+#include "gamebryosavegame.h"
+
 #include <limits>
+#include <set>
+
+using namespace MOBase;
 
 
-using namespace MOShared;
-
-
-template <typename T>
-static void FileRead(QFile &file, T &value)
+SaveGameGamebryo::SaveGameGamebryo(QObject *parent, const QString &fileName, IPluginGame const *game)
+  : SaveGame(parent, fileName, game)
+  , m_Plugins()
 {
-  int read = file.read(reinterpret_cast<char*>(&value), sizeof(T));
-  if (read != sizeof(T)) {
-    throw std::runtime_error("unexpected end of file");
+  SaveGameInfo const *info = game->feature<SaveGameInfo>();
+  if (info != nullptr) {
+    ISaveGame const *save = info->getSaveGameInfo(fileName);
+    m_Save = save;
+
+    //Kludgery
+    GamebryoSaveGame const *s = dynamic_cast<GamebryoSaveGame const *>(save);
+    m_PCName = s->getPCName();
+    m_PCLevel = s->getPCLevel();
+    m_PCLocation = s->getPCLocation();
+    m_SaveNumber = s->getSaveNumber();
+
+    QDateTime modified = s->getCreationTime();
+    memset(&m_CreationTime, 0, sizeof(SYSTEMTIME));
+
+    m_CreationTime.wDay = static_cast<WORD>(modified.date().day());
+    m_CreationTime.wDayOfWeek = static_cast<WORD>(modified.date().dayOfWeek());
+    m_CreationTime.wMonth = static_cast<WORD>(modified.date().month());
+    m_CreationTime.wYear =static_cast<WORD>( modified.date().year());
+
+    m_CreationTime.wHour = static_cast<WORD>(modified.time().hour());
+    m_CreationTime.wMinute = static_cast<WORD>(modified.time().minute());
+    m_CreationTime.wSecond = static_cast<WORD>(modified.time().second());
+    m_CreationTime.wMilliseconds = static_cast<WORD>(modified.time().msec());
+
+    m_Screenshot = s->getScreenshot();
+
+    m_Plugins = s->getPlugins();
   }
 }
-
-
-template <typename T>
-static void FileSkip(QFile &file, int count = 1)
-{
-  char ignore[sizeof(T)];
-  for (int i = 0; i < count; ++i) {
-    if (file.read(ignore, sizeof(T)) != sizeof(T)) {
-      throw std::runtime_error("unexpected end of file");
-    }
-  }
-}
-
-
-static QString ReadBString(QFile &file)
-{
-  char buffer[256];
-  file.read(buffer, 1); // size including zero termination
-  unsigned char size = buffer[0];
-  file.read(buffer, size);
-  return QString::fromLatin1(buffer, size);
-}
-
-
-static QString ReadFOSString(QFile &file, bool delimiter)
-{
-  union {
-    char lengthBuffer[2];
-    unsigned short length;
-  };
-
-  file.read(lengthBuffer, 2);
-  if (delimiter) {
-    FileSkip<char>(file); // 0x7c
-  }
-  char *buffer = new char[length];
-  file.read(buffer, length);
-
-  QString result = QString::fromLatin1(buffer, length);
-  delete [] buffer;
-
-  return result;
-}
-
-
-SaveGameGamebryo::SaveGameGamebryo(QObject *parent)
-  : SaveGame(parent), m_Plugins()
-{
-}
-
-
-SaveGameGamebryo::SaveGameGamebryo(QObject *parent, const QString &fileName)
-  : SaveGame(parent, fileName), m_Plugins()
-{
-  readFile(fileName);
-}
-
-
-SaveGameGamebryo::SaveGameGamebryo(const SaveGameGamebryo& reference)
-  : SaveGame(reference), m_Plugins(reference.m_Plugins)
-{
-}
-
-
-SaveGameGamebryo& SaveGameGamebryo::operator=(const SaveGameGamebryo &reference)
-{
-  if (&reference != this) {
-    SaveGame::operator =(reference);
-    m_Plugins = reference.m_Plugins;
-  }
-  return *this;
-}
-
-
-SaveGameGamebryo::~SaveGameGamebryo()
-{
-}
-
-
-
-
-
-void SaveGameGamebryo::readSkyrimFile(QFile &saveFile)
-{
-  char fileID[14];
-
-  saveFile.read(fileID, 13);
-  fileID[13] = '\0';
-  if (strncmp(fileID, "TESV_SAVEGAME", 13) != 0) {
-    throw std::runtime_error(QObject::tr("wrong file format").toUtf8().constData());
-  }
-
-  FileSkip<unsigned long>(saveFile); // header size
-  FileSkip<unsigned long>(saveFile); // header version, -> 8
-  FileRead(saveFile, m_SaveNumber);
-
-  m_PCName = ReadFOSString(saveFile, false);
-
-  unsigned long temp;
-  FileRead(saveFile, temp); // player level
-  m_PCLevel = static_cast<unsigned short>(temp);
-
-  m_PCLocation = ReadFOSString(saveFile, false);
-  ReadFOSString(saveFile, false); // playtime as ascii hhh.mm.ss
-  ReadFOSString(saveFile, false); // race name (i.e. BretonRace)
-
-
-  FileSkip<unsigned short>(saveFile); // ???
-  FileSkip<float>(saveFile, 2); // ???
-  FileSkip<unsigned char>(saveFile, 8); // filetime
-
-//  FileSkip<unsigned char>(saveFile, 18); // ??? 18 bytes of data. not completely random, maybe a time stamp? maybe
-
-  unsigned long width, height;
-  FileRead(saveFile, width); // 320
-  FileRead(saveFile, height); // 192
-
-  QScopedArrayPointer<unsigned char> buffer(new unsigned char[width * height * 3]);
-  saveFile.read(reinterpret_cast<char*>(buffer.data()), width * height * 3);
-  // why do I have to copy here? without the copy, the buffer seems to get deleted after the
-  // temporary vanishes, but Qts implicit sharing should handle that?
-  m_Screenshot = QImage(buffer.data(), width, height, QImage::Format_RGB888).copy();
-
-  FileSkip<unsigned char>(saveFile); // form version
-  FileSkip<unsigned long>(saveFile); // plugin info size
-
-  unsigned char pluginCount;
-  FileRead(saveFile, pluginCount);
-
-  for (int i = 0; i < pluginCount; ++i) {
-    m_Plugins.push_back(ReadFOSString(saveFile, false));
-  }
-}
-
-
-void SaveGameGamebryo::readESSFile(QFile &saveFile)
-{
-  char fileID[13];
-  unsigned char versionMinor;
-  unsigned long headerVersion, saveHeaderSize;
-// *** format is different for fallout!
-  saveFile.read(fileID, 12);
-  fileID[12] = '\0';
-  FileSkip<unsigned char>(saveFile); FileRead(saveFile, versionMinor);
-  FileSkip<SYSTEMTIME>(saveFile); // modified time
-  FileRead(saveFile, headerVersion); FileRead(saveFile, saveHeaderSize);
-
-  if (strncmp(fileID, "TES4SAVEGAME", 12) != 0) {
-    throw std::runtime_error(QObject::tr("wrong file format").toUtf8().constData());
-  }
-
-  FileRead(saveFile, m_SaveNumber);
-
-  m_PCName = ReadBString(saveFile);
-
-  FileRead(saveFile, m_PCLevel);
-  m_PCLocation = ReadBString(saveFile);
-  FileSkip<float>(saveFile);         // game days
-  FileSkip<unsigned long>(saveFile); // game ticks
-  FileRead(saveFile, m_CreationTime);
-
-  unsigned long size;
-  FileRead(saveFile, size); // screenshot size
-
-  unsigned long width, height;
-  FileRead(saveFile, width); FileRead(saveFile, height);
-  QScopedArrayPointer<unsigned char> buffer(new unsigned char[width * height * 3]);
-  saveFile.read(reinterpret_cast<char*>(buffer.data()), width * height * 3);
-  // why do I have to copy here? without the copy, the buffer seems to get deleted after the
-  // temporary vanishes, but Qts implicit sharing should handle that?
-  m_Screenshot = QImage(buffer.data(), width, height, QImage::Format_RGB888).copy();
-
-  unsigned char pluginCount;
-  FileRead(saveFile, pluginCount);
-
-  for (int i = 0; i < pluginCount; ++i) {
-    QString name = ReadBString(saveFile);
-    m_Plugins.push_back(name);
-  }
-}
-
-
-void SaveGameGamebryo::readFOSFile(QFile &saveFile, bool newVegas)
-{
-  char fileID[13];
-  saveFile.read(fileID, 12);
-  // the signature is only 11 characters, the 12th is random?
-  fileID[11] = '\0';
-
-  if (strncmp(fileID, "FO3SAVEGAME", 11) != 0) {
-    throw std::runtime_error(QObject::tr("wrong file format").toUtf8().constData());
-  }
-
-  char ignore = 0x00;
-  while (ignore != 0x7c) {
-    FileRead<char>(saveFile, ignore); // unknown
-  }
-  if (newVegas) {
-    ignore = 0x00;
-    // in new vegas there is another block of uninteresting (?) information
-    FileSkip<char>(saveFile); // 0x7c
-    while (ignore != 0x7c) {
-      FileRead<char>(saveFile, ignore); // unknown
-    }
-  }
-
-  unsigned long width, height;
-  FileRead(saveFile, width);
-  FileSkip<char>(saveFile); // 0x7c
-  FileRead(saveFile, height);
-  FileSkip<char>(saveFile); // 0x7c
-
-  FileRead(saveFile, m_SaveNumber);
-  FileSkip<char>(saveFile); // 0x7c
-
-  m_PCName = ReadFOSString(saveFile, true);
-  FileSkip<char>(saveFile); // 0x7c
-
-  ReadFOSString(saveFile, true);
-  FileSkip<char>(saveFile); // 0x7c
-
-  long Level;
-  FileRead(saveFile, Level);
-  m_PCLevel = Level;
-  FileSkip<char>(saveFile); // 0x7c
-
-  m_PCLocation = ReadFOSString(saveFile, true);
-  FileSkip<char>(saveFile); // 0x7c
-
-  ReadFOSString(saveFile, true); // playtime
-
-  FileSkip<char>(saveFile);
-
-  QScopedArrayPointer<unsigned char> buffer(new unsigned char[width * height * 3]);
-  saveFile.read(reinterpret_cast<char*>(buffer.data()), width * height * 3);
-  // why do I have to copy here? without the copy, the buffer seems to get deleted after the
-  // temporary vanishes, but Qts implicit sharing should handle that?
-  m_Screenshot = QImage(buffer.data(), width, height, QImage::Format_RGB888).scaledToWidth(256);
-
-  FileSkip<char>(saveFile, 5); // unknown
-
-  unsigned char pluginCount = 0;
-  FileRead(saveFile, pluginCount);
-  FileSkip<char>(saveFile); // 0x7c
-
-  for (int i = 0; i < pluginCount; ++i) {
-    QString name = ReadFOSString(saveFile, true);
-    m_Plugins.push_back(name);
-    FileSkip<char>(saveFile); // 0x7c
-  }
-}
-
-
-void SaveGameGamebryo::setCreationTime(const QString &fileName)
-{
-  QFileInfo creationTime(fileName);
-  QDateTime modified = creationTime.lastModified();
-  memset(&m_CreationTime, 0, sizeof(SYSTEMTIME));
-
-  m_CreationTime.wDay = static_cast<WORD>(modified.date().day());
-  m_CreationTime.wDayOfWeek = static_cast<WORD>(modified.date().dayOfWeek());
-  m_CreationTime.wMonth = static_cast<WORD>(modified.date().month());
-  m_CreationTime.wYear =static_cast<WORD>( modified.date().year());
-
-  m_CreationTime.wHour = static_cast<WORD>(modified.time().hour());
-  m_CreationTime.wMinute = static_cast<WORD>(modified.time().minute());
-  m_CreationTime.wSecond = static_cast<WORD>(modified.time().second());
-  m_CreationTime.wMilliseconds = static_cast<WORD>(modified.time().msec());
-}
-
-
-void SaveGameGamebryo::readFile(const QString &fileName)
-{
-  m_FileName = fileName;
-  QFile saveFile(fileName);
-  if (!saveFile.open(QIODevice::ReadOnly)) {
-    throw std::runtime_error(QObject::tr("failed to open %1").arg(fileName).toUtf8().constData());
-  }
-  switch (GameInfo::instance().getType()) {
-    case GameInfo::TYPE_FALLOUT3: {
-      setCreationTime(fileName);
-      readFOSFile(saveFile, false);
-    } break;
-    case GameInfo::TYPE_FALLOUTNV: {
-      setCreationTime(fileName);
-      readFOSFile(saveFile, true);
-    } break;
-    case GameInfo::TYPE_OBLIVION: {
-      readESSFile(saveFile);
-    } break;
-    case GameInfo::TYPE_SKYRIM: {
-      setCreationTime(fileName);
-      readSkyrimFile(saveFile);
-    } break;
-  }
-
-  saveFile.close();
-}
diff --git a/src/savegamegamebyro.h b/src/savegamegamebyro.h
index e08e1044..bce08018 100644
--- a/src/savegamegamebyro.h
+++ b/src/savegamegamebyro.h
@@ -20,17 +20,13 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #ifndef SAVEGAMEGAMEBRYO_H
 #define SAVEGAMEGAMEBRYO_H
 
-
 #include "savegame.h"
 
-#include <QString>
-#include <QObject>
 #include <QMetaType>
-#include <QFile>
-
-#define WIN32_LEAN_AND_MEAN
-#include <Windows.h>
+#include <QObject>
+#include <QString>
 
+namespace MOBase { class IPluginGame; class ISaveGame; }
 
 /**
  * @brief represents a single save game
@@ -41,31 +37,21 @@ Q_OBJECT
 
 public:
 
-  /**
-   * @brief construct an empty object
-   **/
-  SaveGameGamebryo(QObject *parent = 0);
-
   /**
    * @brief construct a save game and immediately read out information from the file
    *
    * @param filename absolute path of the save game file
    **/
-  SaveGameGamebryo(QObject *parent, const QString &filename);
+  SaveGameGamebryo(QObject *parent, const QString &filename, MOBase::IPluginGame const *game);
 
+  /*
 
   SaveGameGamebryo(const SaveGameGamebryo &reference);
 
   SaveGameGamebryo &operator=(const SaveGameGamebryo &reference);
 
   ~SaveGameGamebryo();
-
-  /**
-   * @brief read out information from a savegame
-   *
-   * @param fileName absolute path of the save game file
-   **/
-  virtual void readFile(const QString &fileName);
+  */
 
   /**
    * @return number of plugins that were enabled when the save game was created
@@ -80,22 +66,12 @@ public:
    **/
   const QString &plugin(int index) const { return m_Plugins.at(index); }
 
-
 private:
 
-  void readESSFile(QFile &saveFile);
-  void readFOSFile(QFile &saveFile, bool newVegas);
-  void readSkyrimFile(QFile &saveFile);
-
-  void setCreationTime(const QString &fileName);
-
-private:
-
-  std::vector<QString> m_Plugins;
+  QStringList m_Plugins;
+  //Note: This isn't owned by us so safe to copy
+  MOBase::ISaveGame const *m_Save;
 
 };
 
-Q_DECLARE_METATYPE(SaveGameGamebryo)
-Q_DECLARE_METATYPE(SaveGameGamebryo*)
-
 #endif // SAVEGAMEGAMEBRYO_H
diff --git a/src/selfupdater.cpp b/src/selfupdater.cpp
index 5cd6cf36..11478fbc 100644
--- a/src/selfupdater.cpp
+++ b/src/selfupdater.cpp
@@ -18,16 +18,18 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "selfupdater.h"
+
 #include "utility.h"
 #include "installationmanager.h"
+#include "iplugingame.h"
 #include "messagedialog.h"
 #include "downloadmanager.h"
 #include "nexusinterface.h"
 #include "nxmaccessmanager.h"
 #include <versioninfo.h>
-#include <gameinfo.h>
-#include <skyriminfo.h>
 #include <report.h>
+#include <util.h>
+
 #include <QMessageBox>
 #include <QNetworkAccessManager>
 #include <QNetworkRequest>
@@ -35,7 +37,6 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include <QLibrary>
 #include <QProcess>
 #include <QApplication>
-#include <util.h>
 #include <boost/bind.hpp>
 
 
@@ -62,6 +63,7 @@ SelfUpdater::SelfUpdater(NexusInterface *nexusInterface)
   , m_UpdateRequestID(-1)
   , m_Reply(nullptr)
   , m_Attempts(3)
+  , m_NexusDownload(nullptr)
 {
   QLibrary archiveLib("dlls\\archive.dll");
   if (!archiveLib.load()) {
@@ -101,12 +103,10 @@ void SelfUpdater::testForUpdate()
     emit updateAvailable();
     return;
   }
-
-  if (m_UpdateRequestID == -1) {
+  if (m_UpdateRequestID == -1 && m_NexusDownload != nullptr) {
     m_UpdateRequestID = m_Interface->requestDescription(
-              SkyrimInfo::getNexusModIDStatic(), this, QVariant(),
-              QString(), ToQString(SkyrimInfo::getNexusInfoUrlStatic()),
-              SkyrimInfo::getNexusGameIDStatic());
+              m_NexusDownload->getNexusModOrganizerID(), this, QVariant(),
+              QString(), m_NexusDownload);
   }
 }
 
@@ -123,9 +123,9 @@ void SelfUpdater::startUpdate()
     if (QMessageBox::question(m_Parent, tr("Update"),
           tr("An update is available (newest version: %1), do you want to install it?").arg(m_NewestVersion),
           QMessageBox::Yes | QMessageBox::No) == QMessageBox::Yes) {
-      m_UpdateRequestID = m_Interface->requestFiles(SkyrimInfo::getNexusModIDStatic(),
-                                                    this, m_NewestVersion,
-                                                    ToQString(SkyrimInfo::getNexusInfoUrlStatic()));
+      m_UpdateRequestID = m_Interface->requestFiles(m_NexusDownload->getNexusModOrganizerID(),
+                                                    this, m_NewestVersion, "",
+                                                    m_NexusDownload);
     }
   }
 }
@@ -159,7 +159,7 @@ void SelfUpdater::download(const QString &downloadLink, const QString &fileName)
   QNetworkRequest request(dlUrl);
   m_Canceled = false;
   m_Reply = accessManager->get(request);
-  m_UpdateFile.setFileName(QDir::fromNativeSeparators(ToQString(GameInfo::instance().getOrganizerDirectory()).append("\\").append(fileName)));
+  m_UpdateFile.setFileName(QDir::fromNativeSeparators(qApp->property("dataPath").toString()).append("/").append(fileName));
   m_UpdateFile.open(QIODevice::WriteOnly);
   showProgress();
 
@@ -243,7 +243,7 @@ void SelfUpdater::downloadCancel()
 
 void SelfUpdater::installUpdate()
 {
-  const QString mopath = QDir::fromNativeSeparators(ToQString(GameInfo::instance().getOrganizerDirectory()));
+  const QString mopath = QDir::fromNativeSeparators(qApp->property("dataPath").toString());
 
   QString backupPath = mopath + "/update_backup";
   QDir().mkdir(backupPath);
@@ -280,9 +280,7 @@ void SelfUpdater::installUpdate()
   }
 
   // now unpack the archive into the mo directory
-  if (!m_ArchiveHandler->extract(QString::fromStdWString(GameInfo::instance().getOrganizerDirectory()),
-         nullptr,
-         nullptr,
+  if (!m_ArchiveHandler->extract(mopath, nullptr, nullptr,
          new MethodCallback<SelfUpdater, void, QString const &>(this, &SelfUpdater::report7ZipError))) {
     throw std::runtime_error("extracting failed");
   }
@@ -418,18 +416,18 @@ void SelfUpdater::nxmFilesAvailable(int, QVariant userData, QVariant resultData,
 
   if (updateFileID != -1) {
     qDebug("update available: %d", updateFileID);
-    m_UpdateRequestID = m_Interface->requestDownloadURL(SkyrimInfo::getNexusModIDStatic(),
-                                    updateFileID, this, updateFileName,
-                                    ToQString(SkyrimInfo::getNexusInfoUrlStatic()));
+    m_UpdateRequestID = m_Interface->requestDownloadURL(m_NexusDownload->getNexusModOrganizerID(),
+                                    updateFileID, this, updateFileName, "",
+                                    m_NexusDownload);
   } else if (mainFileID != -1) {
     qDebug("full download required: %d", mainFileID);
     if (QMessageBox::question(m_Parent, tr("Update"),
             tr("No incremental update available for this version, "
                "the complete package needs to be downloaded (%1 kB)").arg(mainFileSize),
             QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Ok) {
-      m_UpdateRequestID = m_Interface->requestDownloadURL(SkyrimInfo::getNexusModIDStatic(),
-                                    mainFileID, this, mainFileName,
-                                    ToQString(SkyrimInfo::getNexusInfoUrlStatic()));
+      m_UpdateRequestID = m_Interface->requestDownloadURL(m_NexusDownload->getNexusModOrganizerID(),
+                                    mainFileID, this, mainFileName, "",
+                                    m_NexusDownload);
     }
   } else {
     qCritical("no file for update found");
@@ -473,3 +471,9 @@ void SelfUpdater::nxmDownloadURLsAvailable(int, int, QVariant userData, QVariant
     }
   }
 }
+
+/** Set the game check for updates */
+void SelfUpdater::setNexusDownload(MOBase::IPluginGame const *game)
+{
+  m_NexusDownload = game;
+}
diff --git a/src/selfupdater.h b/src/selfupdater.h
index f804f63c..446778fb 100644
--- a/src/selfupdater.h
+++ b/src/selfupdater.h
@@ -29,6 +29,7 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include <QFile>
 #include <QProgressDialog>
 
+namespace MOBase { class IPluginGame; }
 
 class NexusInterface;
 
@@ -83,6 +84,9 @@ public:
    **/
   MOBase::VersionInfo getVersion() const { return m_MOVersion; }
 
+  /** Set the game check for updates */
+  void setNexusDownload(MOBase::IPluginGame const *game);
+
 public slots:
 
   /**
@@ -143,6 +147,7 @@ private:
 
   Archive *m_ArchiveHandler;
 
+  MOBase::IPluginGame const *m_NexusDownload;
 };
 
 
diff --git a/src/settings.cpp b/src/settings.cpp
index 4c2a34c8..479dd3ab 100644
--- a/src/settings.cpp
+++ b/src/settings.cpp
@@ -22,26 +22,22 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 #include "settingsdialog.h"
 #include "utility.h"
 #include "helper.h"
-#include "json.h"
 #include <gameinfo.h>
 #include <appconfig.h>
 #include <utility.h>
 #include <iplugingame.h>
 
 #include <QCheckBox>
-#include <QLineEdit>
-#include <QDirIterator>
-#include <QRegExp>
 #include <QCoreApplication>
-#include <QMessageBox>
 #include <QDesktopServices>
+#include <QDirIterator>
+#include <QLineEdit>
+#include <QMessageBox>
+#include <QRegExp>
 
 #include <memory>
 
-
 using namespace MOBase;
-using namespace MOShared;
-
 
 template <typename T>
 class QListWidgetItemEx : public QListWidgetItem {
@@ -112,7 +108,7 @@ void Settings::registerAsNXMHandler(bool force)
   std::wstring nxmPath = ToWString(QCoreApplication::applicationDirPath() + "/nxmhandler.exe");
   std::wstring executable = ToWString(QCoreApplication::applicationFilePath());
   std::wstring mode = force ? L"forcereg" : L"reg";
-  std::wstring parameters = mode + L" " + GameInfo::instance().getGameShortName() + L" \"" + executable + L"\"";
+  std::wstring parameters = mode + L" " + m_GamePlugin->getGameShortName().toStdWString() + L" \"" + executable + L"\"";
   HINSTANCE res = ::ShellExecuteW(nullptr, L"open", nxmPath.c_str(), parameters.c_str(), nullptr, SW_SHOWNORMAL);
   if ((int)res <= 32) {
     QMessageBox::critical(nullptr, tr("Failed"),
@@ -120,7 +116,7 @@ void Settings::registerAsNXMHandler(bool force)
   }
 }
 
-void Settings::managedGameChanged(IPluginGame *gamePlugin)
+void Settings::managedGameChanged(IPluginGame const *gamePlugin)
 {
   m_GamePlugin = gamePlugin;
 }
diff --git a/src/settings.h b/src/settings.h
index def1dc5c..1ee16e76 100644
--- a/src/settings.h
+++ b/src/settings.h
@@ -299,7 +299,7 @@ public:
 
 public slots:
 
-  void managedGameChanged(MOBase::IPluginGame *gamePlugin);
+  void managedGameChanged(MOBase::IPluginGame const *gamePlugin);
 
 private:
 
@@ -328,7 +328,7 @@ private:
   };
 
   /** Display/store the configuration in the 'general' tab of the settings dialogue */
-  class GeneralTab : SettingsTab
+  class GeneralTab : public SettingsTab
   {
   public:
     GeneralTab(Settings *m_parent, SettingsDialog &m_dialog);
@@ -347,7 +347,7 @@ private:
   };
 
   /** Display/store the configuration in the 'nexus' tab of the settings dialogue */
-  class NexusTab : SettingsTab
+  class NexusTab : public SettingsTab
   {
   public:
     NexusTab(Settings *m_parent, SettingsDialog &m_dialog);
@@ -365,7 +365,7 @@ private:
   };
 
   /** Display/store the configuration in the 'steam' tab of the settings dialogue */
-  class SteamTab : SettingsTab
+  class SteamTab : public SettingsTab
   {
   public:
     SteamTab(Settings *m_parent, SettingsDialog &m_dialog);
@@ -378,7 +378,7 @@ private:
   };
 
   /** Display/store the configuration in the 'plugins' tab of the settings dialogue */
-  class PluginsTab : SettingsTab
+  class PluginsTab : public SettingsTab
   {
   public:
     PluginsTab(Settings *m_parent, SettingsDialog &m_dialog);
@@ -391,7 +391,7 @@ private:
   };
 
   /** Display/store the configuration in the 'workarounds' tab of the settings dialogue */
-  class WorkaroundsTab : SettingsTab
+  class WorkaroundsTab : public SettingsTab
   {
   public:
     WorkaroundsTab(Settings *m_parent, SettingsDialog &m_dialog);
@@ -420,7 +420,7 @@ private:
 
   static Settings *s_Instance;
 
-  MOBase::IPluginGame *m_GamePlugin;
+  MOBase::IPluginGame const *m_GamePlugin;
 
   QSettings m_Settings;
 
diff --git a/src/settingsdialog.cpp b/src/settingsdialog.cpp
index 765858f5..8bc1dbc6 100644
--- a/src/settingsdialog.cpp
+++ b/src/settingsdialog.cpp
@@ -18,22 +18,24 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "settingsdialog.h"
+
 #include "ui_settingsdialog.h"
 #include "categoriesdialog.h"
 #include "helper.h"
 #include "noeditdelegate.h"
-#include <gameinfo.h>
+#include "iplugingame.h"
+#include "settings.h"
+
 #include <QDirIterator>
 #include <QFileDialog>
 #include <QMessageBox>
 #include <QShortcut>
+
 #define WIN32_LEAN_AND_MEAN
 #include <Windows.h>
-#include "settings.h"
 
 
 using namespace MOBase;
-using namespace MOShared;
 
 
 SettingsDialog::SettingsDialog(QWidget *parent)
@@ -87,7 +89,11 @@ void SettingsDialog::on_categoriesBtn_clicked()
 
 void SettingsDialog::on_bsaDateBtn_clicked()
 {
-  Helper::backdateBSAs(GameInfo::instance().getOrganizerDirectory(), GameInfo::instance().getGameDirectory().append(L"\\data"));
+  IPluginGame const *game = qApp->property("managed_game").value<IPluginGame const *>();
+  QDir dir = game->dataDirectory();
+
+  Helper::backdateBSAs(qApp->property("dataPath").toString().toStdWString(),
+                       dir.absolutePath().toStdWString());
 }
 
 void SettingsDialog::on_browseDownloadDirBtn_clicked()
diff --git a/src/shared/fallout3info.cpp b/src/shared/fallout3info.cpp
index f0776a7d..797d68ec 100644
--- a/src/shared/fallout3info.cpp
+++ b/src/shared/fallout3info.cpp
@@ -30,8 +30,8 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 
 namespace MOShared {
 
-Fallout3Info::Fallout3Info(const std::wstring &moDirectory, const std::wstring &moDataDirectory, const std::wstring &gameDirectory)
-  : GameInfo(moDirectory, moDataDirectory, gameDirectory)
+Fallout3Info::Fallout3Info(const std::wstring &gameDirectory)
+  : GameInfo(gameDirectory)
 {
   identifyMyGamesDirectory(L"fallout3");
 }
@@ -63,21 +63,6 @@ std::wstring Fallout3Info::getRegPathStatic()
 }
 
 
-std::vector<std::wstring> Fallout3Info::getDLCPlugins() const
-{
-  return boost::assign::list_of (L"ThePitt.esm")
-                                (L"Anchorage.esm")
-                                (L"BrokenSteel.esm")
-                                (L"PointLookout.esm")
-                                (L"Zeta.esm")
-      ;
-}
-
-std::vector<std::wstring> Fallout3Info::getSavegameAttachmentExtensions() const
-{
-  return std::vector<std::wstring>();
-}
-
 std::vector<std::wstring> Fallout3Info::getIniFileNames() const
 {
   return boost::assign::list_of(L"fallout.ini")(L"falloutprefs.ini");
@@ -88,25 +73,6 @@ std::wstring Fallout3Info::getReferenceDataFile() const
   return L"Fallout - Meshes.bsa";
 }
 
-std::wstring Fallout3Info::getNexusPage(bool nmmScheme) const
-{
-  if (nmmScheme) {
-    return L"http://nmm.nexusmods.com/fallout3";
-  } else {
-    return L"http://www.nexusmods.com/fallout3";
-  }
-}
-
-std::wstring Fallout3Info::getNexusInfoUrlStatic()
-{
-  return L"http://nmm.nexusmods.com/fallout3";
-}
-
-int Fallout3Info::getNexusModIDStatic()
-{
-  return 16348;
-}
-
 bool Fallout3Info::rerouteToProfile(const wchar_t *fileName, const wchar_t*) const
 {
   static LPCWSTR profileFiles[] = { L"fallout.ini", L"falloutprefs.ini", L"plugins.txt", nullptr };
@@ -119,9 +85,4 @@ bool Fallout3Info::rerouteToProfile(const wchar_t *fileName, const wchar_t*) con
   return false;
 }
 
-bool Fallout3Info::isValidModURL(int modID, const std::wstring &url) const
-{
-  return GameInfo::isValidModURL(modID, url, L"http://fallout3.nexusmods.com");
-}
-
 } // namespace MOShared
diff --git a/src/shared/fallout3info.h b/src/shared/fallout3info.h
index fb60d6ae..5cf98e3b 100644
--- a/src/shared/fallout3info.h
+++ b/src/shared/fallout3info.h
@@ -36,38 +36,19 @@ public:
 
   static std::wstring getRegPathStatic();
   virtual std::wstring getRegPath() const { return getRegPathStatic(); }
-  virtual std::wstring getBinaryName() const { return L"Fallout3.exe"; }
-  virtual std::wstring getExtenderName() const { return L"fose_loader.exe"; }
-
-  virtual GameInfo::Type getType() const { return TYPE_FALLOUT3; }
-
-  virtual std::wstring getGameName() const { return L"Fallout 3"; }
-  virtual std::wstring getGameShortName() const { return L"Fallout3"; }
-
-  virtual std::vector<std::wstring> getDLCPlugins() const;
-  virtual std::vector<std::wstring> getSavegameAttachmentExtensions() const;
 
   // file name of this games ini (no path)
   virtual std::vector<std::wstring> getIniFileNames() const;
 
   virtual std::wstring getReferenceDataFile() const;
 
-  virtual std::wstring getNexusPage(bool nmmScheme = true) const;
-  static std::wstring getNexusInfoUrlStatic();
-  virtual std::wstring getNexusInfoUrl() const { return getNexusInfoUrlStatic(); }
-  static int getNexusModIDStatic();
-  virtual int getNexusModID() const { return getNexusModIDStatic(); }
-  virtual int getNexusGameID() const { return 120; }
-
   virtual bool rerouteToProfile(const wchar_t *fileName, const wchar_t *fullPath) const;
 
   virtual std::wstring archiveListKey() const { return L"SArchiveList"; }
 
-  virtual bool isValidModURL(int modID, std::wstring const &url) const;
-
 private:
 
-  Fallout3Info(const std::wstring &moDirectory, const std::wstring &moDataDirectory, const std::wstring &gameDirectory);
+  Fallout3Info(const std::wstring &gameDirectory);
 
   static bool identifyGame(const std::wstring &searchPath);
 
diff --git a/src/shared/falloutnvinfo.cpp b/src/shared/falloutnvinfo.cpp
index f6de72e3..6347224d 100644
--- a/src/shared/falloutnvinfo.cpp
+++ b/src/shared/falloutnvinfo.cpp
@@ -31,8 +31,8 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 namespace MOShared {
 
 
-FalloutNVInfo::FalloutNVInfo(const std::wstring &moDirectory, const std::wstring &moDataDirectory, const std::wstring &gameDirectory)
-  : GameInfo(moDirectory, moDataDirectory, gameDirectory)
+FalloutNVInfo::FalloutNVInfo(const std::wstring &gameDirectory)
+  : GameInfo(gameDirectory)
 {
   identifyMyGamesDirectory(L"falloutnv");
 }
@@ -63,25 +63,6 @@ std::wstring FalloutNVInfo::getRegPathStatic()
   }
 }
 
-std::vector<std::wstring> FalloutNVInfo::getDLCPlugins() const
-{
-  return boost::assign::list_of (L"DeadMoney.esm")
-                                (L"HonestHearts.esm")
-                                (L"OldWorldBlues.esm")
-                                (L"LonesomeRoad.esm")
-                                (L"GunRunnersArsenal.esm")
-                                (L"CaravanPack.esm")
-                                (L"ClassicPack.esm")
-                                (L"MercenaryPack.esm")
-                                (L"TribalPack.esm")
-      ;
-}
-
-std::vector<std::wstring> FalloutNVInfo::getSavegameAttachmentExtensions() const
-{
-  return std::vector<std::wstring>();
-}
-
 std::vector<std::wstring> FalloutNVInfo::getIniFileNames() const
 {
   return boost::assign::list_of(L"fallout.ini")(L"falloutprefs.ini");
@@ -92,28 +73,6 @@ std::wstring FalloutNVInfo::getReferenceDataFile() const
   return L"Fallout - Meshes.bsa";
 }
 
-std::wstring FalloutNVInfo::getNexusPage(bool nmmScheme) const
-{
-  if (nmmScheme) {
-    return L"http://nmm.nexusmods.com/newvegas";
-  } else {
-    return L"http://www.nexusmods.com/newvegas";
-  }
-}
-
-
-std::wstring FalloutNVInfo::getNexusInfoUrlStatic()
-{
-  return L"http://nmm.nexusmods.com/newvegas";
-}
-
-
-int FalloutNVInfo::getNexusModIDStatic()
-{
-  return 42572;
-}
-
-
 bool FalloutNVInfo::rerouteToProfile(const wchar_t *fileName, const wchar_t*) const
 {
   static LPCWSTR profileFiles[] = { L"fallout.ini", L"falloutprefs.ini", L"plugins.txt", nullptr };
@@ -126,9 +85,4 @@ bool FalloutNVInfo::rerouteToProfile(const wchar_t *fileName, const wchar_t*) co
   return false;
 }
 
-bool FalloutNVInfo::isValidModURL(int modID, std::wstring const &url) const
-{
-  return GameInfo::isValidModURL(modID, url, L"http://newvegas.nexusmods.com");
-}
-
 } // namespace MOShared
diff --git a/src/shared/falloutnvinfo.h b/src/shared/falloutnvinfo.h
index 65f17013..04c13c7d 100644
--- a/src/shared/falloutnvinfo.h
+++ b/src/shared/falloutnvinfo.h
@@ -37,38 +37,19 @@ public:
 
   static std::wstring getRegPathStatic();
   virtual std::wstring getRegPath() const { return getRegPathStatic(); }
-  virtual std::wstring getBinaryName() const { return L"FalloutNV.exe"; }
-  virtual std::wstring getExtenderName() const { return L"nvse_loader.exe"; }
-
-  virtual GameInfo::Type getType() const { return TYPE_FALLOUTNV; }
-
-  virtual std::wstring getGameName() const { return L"New Vegas"; }
-  virtual std::wstring getGameShortName() const { return L"FalloutNV"; }
-
-  virtual std::vector<std::wstring> getDLCPlugins() const;
-  virtual std::vector<std::wstring> getSavegameAttachmentExtensions() const;
 
   // file name of this games ini (no path)
   virtual std::vector<std::wstring> getIniFileNames() const;
 
   virtual std::wstring getReferenceDataFile() const;
 
-  virtual std::wstring getNexusPage(bool nmmScheme = true) const;
-  static std::wstring getNexusInfoUrlStatic();
-  virtual std::wstring getNexusInfoUrl() const { return getNexusInfoUrlStatic(); }
-  static int getNexusModIDStatic();
-  virtual int getNexusModID() const { return getNexusModIDStatic(); }
-  virtual int getNexusGameID() const { return 130; }
-
   virtual bool rerouteToProfile(const wchar_t *fileName, const wchar_t *fullPath) const;
 
   virtual std::wstring archiveListKey() const { return L"SArchiveList"; }
 
-  virtual bool isValidModURL(int modID, const std::wstring &url) const;
-
 private:
 
-  FalloutNVInfo(const std::wstring &moDirectory, const std::wstring &moDataDirectory, const std::wstring &gameDirectory);
+  FalloutNVInfo(const std::wstring &gameDirectory);
 
   static bool identifyGame(const std::wstring &searchPath);
 };
diff --git a/src/shared/gameinfo.cpp b/src/shared/gameinfo.cpp
index 5338c069..5c13a520 100644
--- a/src/shared/gameinfo.cpp
+++ b/src/shared/gameinfo.cpp
@@ -40,8 +40,8 @@ namespace MOShared {
 GameInfo* GameInfo::s_Instance = nullptr;
 
 
-GameInfo::GameInfo(const std::wstring &moDirectory, const std::wstring &moDataDirectory, const std::wstring &gameDirectory)
-  : m_GameDirectory(gameDirectory), m_OrganizerDirectory(moDirectory), m_OrganizerDataDirectory(moDataDirectory)
+GameInfo::GameInfo(const std::wstring &gameDirectory)
+  : m_GameDirectory(gameDirectory)
 {
   atexit(&cleanup);
 }
@@ -86,50 +86,36 @@ void GameInfo::identifyMyGamesDirectory(const std::wstring &file)
   }
 }
 
-bool GameInfo::isValidModURL(int modID, const std::wstring &url, const std::wstring &alt) const
-{
-  std::wostringstream os;
-  os << getNexusPage(false) << "/mods/" << modID;
-  if (url == os.str()) {
-    return true;
-  }
-  os.clear();
-  os.str(L"");
-  os << alt << "/mods/" << modID;
-  return url == os.str();
-}
-
-
-bool GameInfo::identifyGame(const std::wstring &moDirectory, const std::wstring &moDataDirectory, const std::wstring &searchPath)
+bool GameInfo::identifyGame(const std::wstring &searchPath)
 {
   if (OblivionInfo::identifyGame(searchPath)) {
-    s_Instance = new OblivionInfo(moDirectory, moDataDirectory, searchPath);
+    s_Instance = new OblivionInfo(searchPath);
   } else if (Fallout3Info::identifyGame(searchPath)) {
-    s_Instance = new Fallout3Info(moDirectory, moDataDirectory, searchPath);
+    s_Instance = new Fallout3Info(searchPath);
   } else if (FalloutNVInfo::identifyGame(searchPath)) {
-    s_Instance = new FalloutNVInfo(moDirectory, moDataDirectory, searchPath);
+    s_Instance = new FalloutNVInfo(searchPath);
   } else if (SkyrimInfo::identifyGame(searchPath)) {
-    s_Instance = new SkyrimInfo(moDirectory, moDataDirectory, searchPath);
+    s_Instance = new SkyrimInfo(searchPath);
   }
 
   return s_Instance != nullptr;
 }
 
 
-bool GameInfo::init(const std::wstring &moDirectory, const std::wstring &moDataDirectory, const std::wstring &gamePath)
+bool GameInfo::init(const std::wstring &moDirectory, const std::wstring &gamePath)
 {
   if (s_Instance == nullptr) {
     if (gamePath.length() == 0) {
       // search upward in the directory until a recognized game-binary is found
       std::wstring searchPath(moDirectory);
-      while (!identifyGame(moDirectory, moDataDirectory, searchPath)) {
+      while (!identifyGame(searchPath)) {
         size_t lastSep = searchPath.find_last_of(L"/\\");
         if (lastSep == std::string::npos) {
           return false;
         }
         searchPath.erase(lastSep);
       }
-    } else if (!identifyGame(moDirectory, moDataDirectory, gamePath)) {
+    } else if (!identifyGame(gamePath)) {
       return false;
     }
   }
@@ -148,24 +134,6 @@ std::wstring GameInfo::getGameDirectory() const
   return m_GameDirectory;
 }
 
-bool GameInfo::requiresSteam() const
-{
-  return FileExists(getGameDirectory() + L"\\steam_api.dll");
-}
-
-std::wstring GameInfo::getLocalAppFolder() const
-{
-  wchar_t localAppFolder[MAX_PATH];
-  memset(localAppFolder, '\0', MAX_PATH * sizeof(wchar_t));
-
-  if (::SHGetFolderPathW(nullptr, CSIDL_LOCAL_APPDATA, nullptr, SHGFP_TYPE_CURRENT, localAppFolder) == S_OK) {
-    return localAppFolder;
-  } else {
-    // fallback: try the registry
-    return getSpecialPath(L"Local AppData");
-  }
-}
-
 std::wstring GameInfo::getSpecialPath(LPCWSTR name) const
 {
   HKEY key;
diff --git a/src/shared/gameinfo.h b/src/shared/gameinfo.h
index 55cd024a..7bc86d3a 100644
--- a/src/shared/gameinfo.h
+++ b/src/shared/gameinfo.h
@@ -38,84 +38,43 @@ namespace MOShared {
 class GameInfo
 {
 
-public:
-
-  enum Type {
-    TYPE_OBLIVION,
-    TYPE_FALLOUT3,
-    TYPE_FALLOUTNV,
-    TYPE_SKYRIM
-  };
-
-  enum LoadOrderMechanism {
-    TYPE_FILETIME,
-    TYPE_PLUGINSTXT
-  };
-
 public:
 
   virtual ~GameInfo() {}
 
-  std::wstring getOrganizerDirectory() const { return m_OrganizerDirectory; }
+  //**USED IN HOOKDLL and at startup to set up for hookdll to work
+  // initialise with the path to the mo directory (needs to be where hook.dll is stored). This
+  // needs to be called before the instance can be retrieved
+  static bool init(const std::wstring &moDirectory, const std::wstring &gamePath = L"");
 
-  virtual std::wstring getRegPath() const = 0;
-  virtual std::wstring getBinaryName() const = 0;
-  virtual std::wstring getExtenderName() const = 0;
-
-  virtual GameInfo::Type getType() const = 0;
-
-  virtual std::wstring getGameName() const = 0;
-  virtual std::wstring getGameShortName() const = 0;
-
-  /// determine the load order mechanism used by this game. this may throw an
-  /// exception if the mechanism can't be determined
-  virtual LoadOrderMechanism getLoadOrderMechanism() const { return TYPE_FILETIME; }
+  //**USED ONLY IN HOOKDLL
+  static GameInfo& instance();
 
+  //**USED ONLY IN HOOKDLL
   virtual std::wstring getGameDirectory() const;
 
-  virtual bool requiresSteam() const;
-
-  // get a list of file extensions for additional files belonging to a save game
-  virtual std::vector<std::wstring> getSavegameAttachmentExtensions() const = 0;
-
-  // get a set of esp/esm files that are part of known dlcs
-  virtual std::vector<std::wstring> getDLCPlugins() const = 0;
+  //**USED ONLY IN HOOKDLL
+  virtual std::wstring getRegPath() const = 0;
 
+  //**USED ONLY IN HOOKDLL
   // file name of this games ini file(s)
   virtual std::vector<std::wstring> getIniFileNames() const = 0;
 
+  //**USED ONLY IN HOOKDLL
   virtual std::wstring getReferenceDataFile() const = 0;
 
-  virtual std::wstring getNexusPage(bool nmmScheme = true) const = 0;
-  virtual std::wstring getNexusInfoUrl() const = 0;
-  virtual int getNexusModID() const = 0;
-  virtual int getNexusGameID() const = 0;
-
+  //**USED ONLY IN HOOKDLL
   virtual bool rerouteToProfile(const wchar_t *fileName, const wchar_t *fullPath) const = 0;
 
-  virtual bool isValidModURL(int modID, std::wstring const &url) const = 0;
-
-public:
-
-  // initialise with the path to the mo directory (needs to be where hook.dll is stored). This
-  // needs to be called before the instance can be retrieved
-  static bool init(const std::wstring &moDirectory, const std::wstring &moDataDirectory, const std::wstring &gamePath = L"");
-
-  static GameInfo& instance();
-
 protected:
 
-  GameInfo(const std::wstring &moDirectory, const std::wstring &moDataDirectory, const std::wstring &gameDirectory);
+  GameInfo(const std::wstring &gameDirectory);
 
-  std::wstring getLocalAppFolder() const;
-  const std::wstring &getMyGamesDirectory() const { return m_MyGamesDirectory; }
   void identifyMyGamesDirectory(const std::wstring &file);
 
-  bool isValidModURL(int modID, const std::wstring &url, const std::wstring &alt) const;
-
 private:
 
-  static bool identifyGame(const std::wstring &moDirectory, const std::wstring &moDataDirectory, const std::wstring &searchPath);
+  static bool identifyGame(const std::wstring &searchPath);
   std::wstring getSpecialPath(LPCWSTR name) const;
 
   static void cleanup();
@@ -127,8 +86,6 @@ private:
   std::wstring m_MyGamesDirectory;
 
   std::wstring m_GameDirectory;
-  std::wstring m_OrganizerDirectory;
-  std::wstring m_OrganizerDataDirectory;
 
 };
 
diff --git a/src/shared/oblivioninfo.cpp b/src/shared/oblivioninfo.cpp
index 730c186b..b50f1daa 100644
--- a/src/shared/oblivioninfo.cpp
+++ b/src/shared/oblivioninfo.cpp
@@ -31,8 +31,8 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 namespace MOShared {
 
 
-OblivionInfo::OblivionInfo(const std::wstring &moDirectory, const std::wstring &moDataDirectory, const std::wstring &gameDirectory)
-  : GameInfo(moDirectory, moDataDirectory, gameDirectory)
+OblivionInfo::OblivionInfo(const std::wstring &gameDirectory)
+  : GameInfo(gameDirectory)
 {
   identifyMyGamesDirectory(L"oblivion");
 }
@@ -63,54 +63,11 @@ std::wstring OblivionInfo::getRegPathStatic()
   }
 }
 
-std::vector<std::wstring> OblivionInfo::getDLCPlugins() const
-{
-  return boost::assign::list_of (L"DLCShiveringIsles.esp")
-                                (L"Knights.esp")
-                                (L"DLCFrostcrag.esp")
-                                (L"DLCSpellTomes.esp")
-                                (L"DLCMehrunesRazor.esp")
-                                (L"DLCOrrery.esp")
-                                (L"DLCSpellTomes.esp")
-                                (L"DLCThievesDen.esp")
-                                (L"DLCVileLair.esp")
-                                (L"DLCHorseArmor.esp")
-      ;
-}
-
-
-std::vector<std::wstring> OblivionInfo::getSavegameAttachmentExtensions() const
-{
-  return boost::assign::list_of(L"obse");
-}
-
-
 std::vector<std::wstring> OblivionInfo::getIniFileNames() const
 {
   return boost::assign::list_of(L"oblivion.ini")(L"oblivionprefs.ini");
 }
 
-std::wstring OblivionInfo::getNexusPage(bool nmmScheme) const
-{
-  if (nmmScheme) {
-    return L"http://nmm.nexusmods.com/oblivion";
-  } else {
-    return L"http://www.nexusmods.com/oblivion";
-  }
-}
-
-
-std::wstring OblivionInfo::getNexusInfoUrlStatic()
-{
-  return L"http://nmm.nexusmods.com/oblivion";
-}
-
-
-int OblivionInfo::getNexusModIDStatic()
-{
-  return 38277;
-}
-
 bool OblivionInfo::rerouteToProfile(const wchar_t *fileName, const wchar_t*) const
 {
   static LPCWSTR profileFiles[] = { L"oblivion.ini", L"oblivionprefs.ini", L"plugins.txt", nullptr };
@@ -128,9 +85,4 @@ std::wstring OblivionInfo::getReferenceDataFile() const
   return L"Oblivion - Meshes.bsa";
 }
 
-bool OblivionInfo::isValidModURL(int modID, const std::wstring &url) const
-{
-  return GameInfo::isValidModURL(modID, url, L"http://oblivion.nexusmods.com");
-}
-
 } // namespace MOShared
diff --git a/src/shared/oblivioninfo.h b/src/shared/oblivioninfo.h
index 74e3fec6..bf0b2707 100644
--- a/src/shared/oblivioninfo.h
+++ b/src/shared/oblivioninfo.h
@@ -35,38 +35,19 @@ public:
 
   static std::wstring getRegPathStatic();
   virtual std::wstring getRegPath() const { return getRegPathStatic(); }
-  virtual std::wstring getBinaryName() const { return L"Oblivion.exe"; }
-  virtual std::wstring getExtenderName() const { return L"obse_loader.exe"; }
-
-  virtual GameInfo::Type getType() const { return TYPE_OBLIVION; }
-
-  virtual std::wstring getGameName() const { return L"Oblivion"; }
-  virtual std::wstring getGameShortName() const { return L"Oblivion"; }
-
-  virtual std::vector<std::wstring> getDLCPlugins() const;
-  virtual std::vector<std::wstring> getSavegameAttachmentExtensions() const;
 
   // file name of this games ini (no path)
   virtual std::vector<std::wstring> getIniFileNames() const;
 
   virtual std::wstring getReferenceDataFile() const;
 
-  virtual std::wstring getNexusPage(bool nmmScheme = true) const;
-  static std::wstring getNexusInfoUrlStatic();
-  virtual std::wstring getNexusInfoUrl() const { return getNexusInfoUrlStatic(); }
-  static int getNexusModIDStatic();
-  virtual int getNexusModID() const { return getNexusModIDStatic(); }
-  virtual int getNexusGameID() const { return 101; }
-
   virtual bool rerouteToProfile(const wchar_t *fileName, const wchar_t *fullPath) const;
 
   virtual std::wstring archiveListKey() const { return L"SArchiveList"; }
 
-  virtual bool isValidModURL(int modID, std::wstring const &url) const;
-
 private:
 
-  OblivionInfo(const std::wstring &moDirectory, const std::wstring &moDataDirectory, const std::wstring &gameDirectory);
+  OblivionInfo(const std::wstring &gameDirectory);
 
   static bool identifyGame(const std::wstring &searchPath);
 
diff --git a/src/shared/skyriminfo.cpp b/src/shared/skyriminfo.cpp
index 7c85fe10..9662e66d 100644
--- a/src/shared/skyriminfo.cpp
+++ b/src/shared/skyriminfo.cpp
@@ -33,8 +33,8 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 namespace MOShared {
 
 
-SkyrimInfo::SkyrimInfo(const std::wstring &moDirectory, const std::wstring &moDataDirectory, const std::wstring &gameDirectory)
-  : GameInfo(moDirectory, moDataDirectory, gameDirectory)
+SkyrimInfo::SkyrimInfo(const std::wstring &gameDirectory)
+  : GameInfo(gameDirectory)
 {
   identifyMyGamesDirectory(L"skyrim");
 
@@ -73,40 +73,6 @@ std::wstring SkyrimInfo::getRegPathStatic()
   }
 }
 
-GameInfo::LoadOrderMechanism SkyrimInfo::getLoadOrderMechanism() const
-{
-  std::wstring fileName = getGameDirectory() + L"\\TESV.exe";
-
-  try {
-    VS_FIXEDFILEINFO versionInfo = GetFileVersion(fileName);
-    if ((versionInfo.dwFileVersionMS > 0x10004) || // version >= 1.5.x?
-        ((versionInfo.dwFileVersionMS == 0x10004) && (versionInfo.dwFileVersionLS >= 0x1A0000))) { // version >= ?.4.26
-      return TYPE_PLUGINSTXT;
-    } else {
-      return TYPE_FILETIME;
-    }
-  } catch (const std::exception &e) {
-    log("TESV.exe is invalid: %s", e.what());
-    return TYPE_FILETIME;
-  }
-}
-
-std::vector<std::wstring> SkyrimInfo::getDLCPlugins() const
-{
-  return boost::assign::list_of (L"Dawnguard.esm")
-                                (L"Dragonborn.esm")
-                                (L"HearthFires.esm")
-                                (L"HighResTexturePack01.esp")
-                                (L"HighResTexturePack02.esp")
-                                (L"HighResTexturePack03.esp")
-      ;
-}
-
-std::vector<std::wstring> SkyrimInfo::getSavegameAttachmentExtensions() const
-{
-  return boost::assign::list_of(L"skse");
-}
-
 std::vector<std::wstring> SkyrimInfo::getIniFileNames() const
 {
   return boost::assign::list_of(L"skyrim.ini")(L"skyrimprefs.ini");
@@ -117,28 +83,6 @@ std::wstring SkyrimInfo::getReferenceDataFile() const
   return L"Skyrim - Meshes.bsa";
 }
 
-
-std::wstring SkyrimInfo::getNexusPage(bool nmmScheme) const
-{
-  if (nmmScheme) {
-    return L"http://nmm.nexusmods.com/skyrim";
-  } else {
-    return L"http://www.nexusmods.com/skyrim";
-  }
-}
-
-
-std::wstring SkyrimInfo::getNexusInfoUrlStatic()
-{
-  return L"http://nmm.nexusmods.com/skyrim";
-}
-
-
-int SkyrimInfo::getNexusModIDStatic()
-{
-  return 1334;
-}
-
 bool SkyrimInfo::rerouteToProfile(const wchar_t *fileName, const wchar_t *fullPath) const
 {
   static LPCWSTR profileFiles[] = { L"skyrim.ini", L"skyrimprefs.ini", L"loadorder.txt", nullptr };
@@ -157,10 +101,4 @@ bool SkyrimInfo::rerouteToProfile(const wchar_t *fileName, const wchar_t *fullPa
   return false;
 }
 
-bool SkyrimInfo::isValidModURL(int modID, const std::wstring &url) const
-{
-  return GameInfo::isValidModURL(modID, url, L"http://skyrim.nexusmods.com");
-}
-
-
 } // namespace MOShared
diff --git a/src/shared/skyriminfo.h b/src/shared/skyriminfo.h
index 538fffb4..bd329403 100644
--- a/src/shared/skyriminfo.h
+++ b/src/shared/skyriminfo.h
@@ -37,41 +37,17 @@ public:
 
   static std::wstring getRegPathStatic();
   virtual std::wstring getRegPath() const { return getRegPathStatic(); }
-  virtual std::wstring getBinaryName() const { return L"TESV.exe"; }
-  virtual std::wstring getExtenderName() const { return L"skse_loader.exe"; }
-
-  virtual GameInfo::Type getType() const { return TYPE_SKYRIM; }
-
-  virtual std::wstring getGameName() const { return L"Skyrim"; }
-  virtual std::wstring getGameShortName() const { return L"Skyrim"; }
-
-  virtual LoadOrderMechanism getLoadOrderMechanism() const;
-
-  virtual std::vector<std::wstring> getDLCPlugins() const;
-
-  virtual std::vector<std::wstring> getSavegameAttachmentExtensions() const;
 
   // file name of this games ini (no path)
   virtual std::vector<std::wstring> getIniFileNames() const;
 
   virtual std::wstring getReferenceDataFile() const;
 
-  virtual std::wstring getNexusPage(bool nmmScheme = true) const;
-
-  static std::wstring getNexusInfoUrlStatic();
-  virtual std::wstring getNexusInfoUrl() const { return getNexusInfoUrlStatic(); }
-  static int getNexusModIDStatic();
-  virtual int getNexusModID() const { return getNexusModIDStatic(); }
-  static int getNexusGameIDStatic() { return 110; }
-  virtual int getNexusGameID() const { return getNexusGameIDStatic(); }
-
   virtual bool rerouteToProfile(const wchar_t *fileName, const wchar_t *fullPath) const;
 
-  virtual bool isValidModURL(int modID, std::wstring const &url) const;
-
 private:
 
-  SkyrimInfo(const std::wstring &moDirectory, const std::wstring &moDataDirectory, const std::wstring &gameDirectory);
+  SkyrimInfo(const std::wstring &gameDirectory);
 
   static bool identifyGame(const std::wstring &searchPath);
 
diff --git a/src/shared/stackdata.cpp b/src/shared/stackdata.cpp
index 6c5a0968..b336593a 100644
--- a/src/shared/stackdata.cpp
+++ b/src/shared/stackdata.cpp
@@ -24,7 +24,7 @@ static void initDbgIfNecess()
       firstCall = false;
     }
     if (!::SymInitialize(process, NULL, TRUE)) {
-      printf("failed to initialize symbols: %d", ::GetLastError());
+      printf("failed to initialize symbols: %lu", ::GetLastError());
     }
     initialized.insert(::GetCurrentProcessId());
   }
@@ -99,7 +99,8 @@ void StackData::initTrace() {
   CONTEXT context;
   std::memset(&context, 0, sizeof(CONTEXT));
   context.ContextFlags = CONTEXT_CONTROL;
-#if BOOST_ARCH_X86_64
+  //Why only for 64 bit?
+#if BOOST_ARCH_X86_64 || defined(__clang__)
   ::RtlCaptureContext(&context);
 #else
   __asm
diff --git a/src/spawn.cpp b/src/spawn.cpp
index c79714bb..49e89a8b 100644
--- a/src/spawn.cpp
+++ b/src/spawn.cpp
@@ -18,18 +18,20 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "spawn.h"
+
 #include "report.h"
 #include "utility.h"
-#include <boost/scoped_array.hpp>
-#include <gameinfo.h>
 #include <report.h>
 #include <inject.h>
-#include <Shellapi.h>
 #include <appconfig.h>
 #include <windows_error.h>
+
 #include <QApplication>
 #include <QMessageBox>
 
+#include <Shellapi.h>
+
+#include <boost/scoped_array.hpp>
 
 using namespace MOBase;
 using namespace MOShared;
diff --git a/src/syncoverwritedialog.cpp b/src/syncoverwritedialog.cpp
index 0e3e98d7..aeed0a55 100644
--- a/src/syncoverwritedialog.cpp
+++ b/src/syncoverwritedialog.cpp
@@ -18,10 +18,11 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "syncoverwritedialog.h"
+
 #include "ui_syncoverwritedialog.h"
 #include <utility.h>
 #include <report.h>
-#include <gameinfo.h>
+
 #include <QDir>
 #include <QDirIterator>
 #include <QComboBox>
diff --git a/src/transfersavesdialog.cpp b/src/transfersavesdialog.cpp
index 73267f75..48fc4548 100644
--- a/src/transfersavesdialog.cpp
+++ b/src/transfersavesdialog.cpp
@@ -18,12 +18,15 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "transfersavesdialog.h"
+
 #include "ui_transfersavesdialog.h"
+#include "iplugingame.h"
 #include "savegamegamebyro.h"
 #include "utility.h"
-#include <gameinfo.h>
+
 #include <QDir>
 #include <QMessageBox>
+
 #include <Shlwapi.h>
 #include <shlobj.h>
 
@@ -32,7 +35,7 @@ using namespace MOBase;
 using namespace MOShared;
 
 
-TransferSavesDialog::TransferSavesDialog(const Profile &profile, IPluginGame *gamePlugin, QWidget *parent)
+TransferSavesDialog::TransferSavesDialog(const Profile &profile, IPluginGame const *gamePlugin, QWidget *parent)
   : TutorableDialog("TransferSaves", parent)
   , ui(new Ui::TransferSavesDialog)
   , m_Profile(profile)
@@ -60,7 +63,7 @@ void TransferSavesDialog::refreshGlobalSaves()
   QStringList files = savesDir.entryList(QDir::Files, QDir::Time);
 
   for (const QString &filename : files) {
-    SaveGameGamebryo *save = new SaveGameGamebryo(this, savesDir.absoluteFilePath(filename));
+    SaveGameGamebryo *save = new SaveGameGamebryo(this, savesDir.absoluteFilePath(filename), m_GamePlugin);
     save->setParent(this);
     m_GlobalSaves.push_back(save);
   }
@@ -78,7 +81,7 @@ void TransferSavesDialog::refreshLocalSaves()
   QStringList files = savesDir.entryList(QDir::Files, QDir::Time);
 
   foreach (const QString &filename, files) {
-    SaveGameGamebryo *save = new SaveGameGamebryo(this, savesDir.absoluteFilePath(filename));
+    SaveGameGamebryo *save = new SaveGameGamebryo(this, savesDir.absoluteFilePath(filename), m_GamePlugin);
     save->setParent(this);
     m_LocalSaves.push_back(save);
   }
diff --git a/src/transfersavesdialog.h b/src/transfersavesdialog.h
index b9265b6a..e2c556b4 100644
--- a/src/transfersavesdialog.h
+++ b/src/transfersavesdialog.h
@@ -22,11 +22,9 @@ along with Mod Organizer.  If not, see <http://www.gnu.org/licenses/>.
 
 #include "tutorabledialog.h"
 #include "profile.h"
-#include <iplugingame.h>
 
-namespace Ui {
-class TransferSavesDialog;
-}
+namespace Ui { class TransferSavesDialog; }
+namespace MOBase { class IPluginGame; }
 
 class SaveGame;
 
@@ -35,7 +33,7 @@ class TransferSavesDialog : public MOBase::TutorableDialog
   Q_OBJECT
   
 public:
-  explicit TransferSavesDialog(const Profile &profile, MOBase::IPluginGame *gamePlugin, QWidget *parent = 0);
+  explicit TransferSavesDialog(const Profile &profile, MOBase::IPluginGame const *gamePlugin, QWidget *parent = 0);
   ~TransferSavesDialog();
   
 private slots:
@@ -76,7 +74,7 @@ private:
 
   Profile m_Profile;
 
-  MOBase::IPluginGame *m_GamePlugin;
+  MOBase::IPluginGame const *m_GamePlugin;
 
   std::vector<SaveGame*> m_GlobalSaves;
   std::vector<SaveGame*> m_LocalSaves;
diff --git a/win.imp b/win.imp
new file mode 100644
index 00000000..cbecdc43
--- /dev/null
+++ b/win.imp
@@ -0,0 +1,83 @@
+[
+    # Microsft visual C?
+
+    { include: [ "<xiosbase>", "private", "<ios_base>", "public" ] },
+    { include: [ "<xlocale>", "private", "<locale>", "public" ] },
+    { include: [ "<xstring>", "private", "<string>", "public" ] },
+    { include: [ "<xutility>", "private", "<utility>", "public" ] },
+
+    { include: [ "<sys/stat.inl>", "private", "<sys/stat.h>", "public" ] },
+
+# Windows
+# Looks like the documentation says the 1st char is u/c the rest are l/c
+
+# You have to be kidding me. ULONG is defined in winsmcrd.h?
+    { symbol: [ "ULONG", "private", "<windef.h>", "private" ] },
+
+    { include: [ "<winnls.h>", "private", "<stringapiset.h>", "private" ] }, # Stringapiset.h
+    { include: [ "<stringapiset.h>", "private", "<Windows.h>", "public" ] },
+
+# These are all in windef.h apparently. Which m/s then says 'use Windows.h'
+    { include: [ "<basetsd.h>", "private", "<windef.h>", "private" ] }, # or in winnt apparently
+    { include: [ "<handleapi.h>", "private", "<windef.h>", "private" ] },
+    { include: [ "<libloaderapi.h>", "private", "<windef.h>", "private" ] },
+    { include: [ "<minwindef.h>", "private", "<windef.h>", "private" ] },
+
+# Similary, but for winbase.h
+    { include: [ "<LMCons.h>", "private", "<winbase.h>", "private" ] },
+    { include: [ "<errhandlingapi.h>", "private", "<winbase.h>", "private" ] },
+    { include: [ "<excpt.h>", "private", "<winbase.h>", "private" ] },
+    { include: [ "<minwinbase.h>", "private", "<winbase.h>", "private" ] },
+    { include: [ "<namedpipeapi.h>", "private", "<winbase.h>", "private" ] },
+    { include: [ "<securitybaseapi.h>", "private", "<winbase.h>", "private" ] },
+
+# These ones say xxxx.h (include Windows.h) on the ms web site
+    { include: [ "<datetimeapi.h>", "private", "<Windows.h>", "public" ] },
+    { include: [ "<fileapi.h>", "private", "<Windows.h>", "public" ] },
+    { include: [ "<verrsrc.h>", "private", "<Windows.h>", "public" ] }, # VerRsrc.h
+    { include: [ "<winbase.h>", "private", "<Windows.h>", "public" ] },
+    { include: [ "<windef.h>", "private", "<Windows.h>", "public" ] },
+    { include: [ "<winerror.h>", "private", "<Windows.h>", "public" ] },
+    { include: [ "<winnt.h>", "private", "<Windows.h>", "public" ] },
+    { include: [ "<winuser.h>", "private", "<Windows.h>", "public" ] },
+
+# These ones are in Windows.h but the documentation post windows 8 says they are individual headers,
+# which looks like M/S are trying to get their act together. Maybe.
+    { include: [ "<processenv.h>", "private", "<Windows.h>", "public" ] },
+    { include: [ "<processthreadsapi.h>", "private", "<Windows.h>", "public" ] },
+    { include: [ "<synchapi.h>", "private", "<Windows.h>", "public" ] },
+
+# These ones are *not* defined to be in Windows.h, but it seems to work. These should probably be cleaned up
+    { include: [ "<DbgHelp.h>", "private", "<Windows.h>", "public" ] },
+    # These 3 should go to Shellapi.h
+    { include: [ "<ShellAPI.h>", "private", "<Windows.h>", "public" ] },
+    { include: [ "<Shellapi.h>", "private", "<Windows.h>", "public" ] }, # official name according to website
+    { include: [ "<shellapi.h>", "private", "<Windows.h>", "public" ] },
+    #
+    { include: [ "<knownfolders.h>", "private", "<Windows.h>", "public" ] },
+    { include: [ "<ShlObj.h>", "private", "<Windows.h>", "public" ] },
+    { include: [ "<objidl.h>", "private", "<Windows.h>", "public" ] },
+
+# Files that are included by other files which seem to then come for free in Windows.h but
+# shouldn't. Again, should be cleaned up.
+    
+    { include: [ "<basetyps.h>", "private", "<objbase.h>", "private" ] },
+    { include: [ "<combaseapi.h>", "private", "<objbase.h>", "private" ] },
+    { include: [ "<objbase.h>", "private", "<Windows.h>", "public" ] },
+
+    { include: [ "<wtypesbase.h>", "private", "<WTypes.h>", "private" ] },
+    { include: [ "<WTypes.h>", "private", "<Windows.h>", "public" ] },
+
+    { include: [ "<guiddef.h>", "private", "<Rpc.h>", "private" ] },
+    { include: [ "<Rpc.h>", "private", "<Windows.h>", "public" ] },
+
+# Huh? This one is sane?
+    { include: [ "<shlguid.h>", "private", "<shobjidl.h>", "public" ] },
+
+
+]
+
+#include <crtdbg.h>                                // for operator delete[], etc
+
+#include <xmemory0>                 // for _Simple_types<>::value_type
+#include <xtree>                          // for _Tree_const_iterator