diff --git a/bin/syncqt.pl b/bin/syncqt.pl
index ac8aa1a0f77..0c10ccbe14e 100755
--- a/bin/syncqt.pl
+++ b/bin/syncqt.pl
@@ -189,6 +189,7 @@ sub shouldMasterInclude {
     if (open(F, "<$iheader")) {
         while (<F>) {
             chomp;
+            chop if /\r$/;
             return 0 if (/^\#pragma qt_no_master_include$/);
         }
         close(F);
diff --git a/config.tests/unix/alsa/alsatest.cpp b/config.tests/unix/alsa/alsatest.cpp
index f93eda4a376..1b2b141b793 100644
--- a/config.tests/unix/alsa/alsatest.cpp
+++ b/config.tests/unix/alsa/alsatest.cpp
@@ -38,7 +38,7 @@
 ****************************************************************************/
 
 #include <alsa/asoundlib.h>
-#if(!(SND_LIB_MAJOR == 1 && SND_LIB_MINOR == 0 && SND_LIB_SUBMINOR >= 10))
+#if SND_LIB_VERSION < 0x1000a  // 1.0.10
 #error "Alsa version found too old, require >= 1.0.10"
 #endif
 
diff --git a/configure b/configure
index 2c5fd6b66c0..4613f5d6cd0 100755
--- a/configure
+++ b/configure
@@ -756,6 +756,7 @@ XPLATFORM_ANDROID=no
 XPLATFORM_MINGW=no      # Whether target platform is MinGW (win32-g++*)
 XPLATFORM_QNX=no
 XPLATFORM_HAIKU=no
+XPLATFORM_INTEGRITY=no
 PLATFORM=$QMAKESPEC
 QT_CROSS_COMPILE=no
 OPT_CONFIRM_LICENSE=no
@@ -2990,6 +2991,9 @@ case "$XPLATFORM" in
     *macx*)
         XPLATFORM_MAC=yes
         ;;
+    *integrity*)
+        XPLATFORM_INTEGRITY=yes
+        ;;
     # XPLATFORM_ANDROID should not be set for unsupported/android-g++
     *unsupported*)
         ;;
@@ -4659,6 +4663,11 @@ if [ "$XPLATFORM_QNX" = "yes" ]; then
     fi
 fi
 
+if [ "$XPLATFORM_INTEGRITY" = "yes" ]; then
+    CFG_SHARED=no
+    CFG_LARGEFILE=no
+fi
+
 # detect zlib
 if [ "$CFG_SYSTEM_ZLIB" = "auto" ]; then
     if compileTest unix/zlib "zlib"; then
@@ -5889,7 +5898,7 @@ if [ "$CFG_MIRCLIENT" = "yes" ]; then
     QT_CONFIG="$QT_CONFIG mirclient"
 fi
 
-if [ "$XPLATFORM_MAC" = "no" ] && [ "$XPLATFORM_MINGW" = "no" ] && [ "$XPLATFORM_QNX" = "no" ] && [ "$XPLATFORM_ANDROID" = "no" ] && [ "$XPLATFORM_HAIKU" = "no" ]; then
+if [ "$XPLATFORM_MAC" = "no" ] && [ "$XPLATFORM_MINGW" = "no" ] && [ "$XPLATFORM_QNX" = "no" ] && [ "$XPLATFORM_ANDROID" = "no" ] && [ "$XPLATFORM_HAIKU" = "no" ] && [ "$XPLATFORM_INTEGRITY" = "no" ]; then
     if [ "$CFG_XCB" = "no" ] && [ "$CFG_EGLFS" = "no" ] && [ "$CFG_DIRECTFB" = "no" ] && [ "$CFG_LINUXFB" = "no" ] && [ "$CFG_MIRCLIENT" = "no" ]; then
         if [ "$QPA_PLATFORM_GUARD" = "yes" ] &&
             ( [ "$ORIG_CFG_XCB" = "auto" ] || [ "$ORIG_CFG_EGLFS" = "auto" ] || [ "$ORIG_CFG_DIRECTFB" = "auto" ] || [ "$ORIG_CFG_LINUXFB" = "auto" ] || [ "$ORIG_CFG_MIRCLIENT" = "auto" ] ); then
@@ -6447,9 +6456,9 @@ fi
 [ "$CFG_SYSTEM_PROXIES" = "yes" ] && QT_CONFIG="$QT_CONFIG system-proxies"
 [ "$CFG_DIRECTWRITE" = "yes" ] && QT_CONFIG="$QT_CONFIG directwrite"
 
-[ '!' -z "$DEFINES" ] && QMakeVar add DEFINES "$DEFINES"
-[ '!' -z "$INCLUDES" ] && QMakeVar add INCLUDEPATH "$INCLUDES"
-[ '!' -z "$L_FLAGS" ] && QMakeVar add LIBS "$L_FLAGS"
+[ '!' -z "$DEFINES" ] && QMakeVar add EXTRA_DEFINES "$DEFINES"
+[ '!' -z "$INCLUDES" ] && QMakeVar add EXTRA_INCLUDEPATH "$INCLUDES"
+[ '!' -z "$L_FLAGS" ] && QMakeVar add EXTRA_LIBS "$L_FLAGS"
 
 if [ -z "`getXQMakeConf 'QMAKE_(LFLAGS_)?RPATH'`" ]; then
     if [ -n "$RPATH_FLAGS" ]; then
@@ -6465,7 +6474,7 @@ if [ -z "`getXQMakeConf 'QMAKE_(LFLAGS_)?RPATH'`" ]; then
 else
     if [ -n "$RPATH_FLAGS" ]; then
         # add the user defined rpaths
-	QMakeVar add QMAKE_RPATHDIR "$RPATH_FLAGS"
+        QMakeVar add EXTRA_RPATHS "$RPATH_FLAGS"
     fi
 fi
 if [ "$CFG_RPATH" = "yes" ]; then
@@ -6923,9 +6932,6 @@ if [ -n "$CFG_SYSROOT" ] && [ "$CFG_GCC_SYSROOT" = "yes" ]; then
     echo "}"
     echo
 fi
-if [ -n "$RPATH_FLAGS" ]; then
-    echo "QMAKE_RPATHDIR += $RPATH_FLAGS"
-fi
 if [ -n "$QT_GCC_MAJOR_VERSION" ]; then
     echo "QT_GCC_MAJOR_VERSION = $QT_GCC_MAJOR_VERSION"
     echo "QT_GCC_MINOR_VERSION = $QT_GCC_MINOR_VERSION"
diff --git a/dist/changes-5.6.0 b/dist/changes-5.6.0
new file mode 100644
index 00000000000..1a2334041f3
--- /dev/null
+++ b/dist/changes-5.6.0
@@ -0,0 +1,519 @@
+Qt 5.6 introduces many new features and improvements along with bug fixes
+over the 5.5.x series. For more details, refer to the online documentation
+included in this distribution. The documentation is also available online:
+
+  http://doc.qt.io/qt-5.6
+
+The Qt version 5.6 series is binary compatible with the 5.5.x series.
+Applications compiled for 5.5 will continue to run with 5.6.
+
+Some of the changes listed in this file include issue tracking numbers
+corresponding to tasks in the Qt Bug Tracker:
+
+  http://bugreports.qt.io/
+
+Each of these identifiers can be entered in the bug tracker to obtain more
+information about a particular change.
+
+****************************************************************************
+*                          Deprecation Notice                              *
+****************************************************************************
+
+   The following platforms or toolchains are deprecated and will be
+   removed as of Qt 5.7:
+   * Apple OS X 10.7 (Lion)
+   * GNU Compiler Collection (GCC) versions 4.6 and earlier
+   * Microsoft Visual Studio compiler versions 2008, 2010 and 2012
+   * Microsoft Windows XP, Windows Vista
+   * Microsoft Windows Embedded Compact 7
+   * Microsoft Windows Embedded Compact 2013
+
+   Deprecated platforms and toolchains continue to work until removed.
+
+ - The QtScript module is deprecated and will be removed from Qt's binary
+   packages starting with version 5.7. The 5.6 releases of QtScript
+   should continue to work along with Qt 5.7 and future versions.
+
+****************************************************************************
+*                          Future Direction Notice                         *
+****************************************************************************
+
+ - In Qt 6, QCoreApplication::notify() will not be called for events being
+   delivered to objects outside the main thread. The reason for that is
+   that the main application object may begin destruction while those
+   threads are still delivering events, which is undefined behavior.
+   Applications that currently override notify() and use that function
+   outside the main thread are advised to find other solutions in the mean
+   time.
+
+ - Qt 5.7 will begin requiring certain C++11 features in order to
+   compile. The minimum compiler versions for that release will be:
+   * Clang 3.4 (included in XCode 5.1)
+   * GCC 4.7
+   * Intel C++ Composer XE 2013 SP1 (compiler version 14.0)
+   * Microsoft Visual Studio 2013 (compiler version 19.0)
+
+****************************************************************************
+*                        Important Behavior Changes                        *
+****************************************************************************
+
+ - SecureTransport is the default SSL backend on OS X. Use the
+   -no-securetransport configure option to use OpenSSL.
+ - [QTBUG-34611] Arrow indicator is now consistent with platform styles
+ - QtDBus now uses threads to implement processing of incoming and outgoing
+   messages. This solves a number of thread safety issues and fixes an
+   architectural problem that would cause all processing to stop if a
+   particular thread (usually the main thread) is blocked in any
+   operation. On the flip side, application developers need to know that
+   modifications to a QDBusConnection may be visible immediately on the
+   connection, so they should be done in an order that won't allow for
+   incomplete states to be observed (for example, register all objects
+   before acquiring service names).
+
+configure & build system
+------------------------
+
+ - [Unix] Qt's .prl files do not expose private dependencies any more.
+   Projects must explicitly name their dependencies.
+ - [Windows] Enabling link-time code generation in Qt does not enable
+   it in user applications as well any more.
+ - [FreeBSD] The "freebsd-clang" mkspec is no longer in the unsupported/
+   subdir. If you use scripts to build Qt, you'll need to update them to
+   include "-platform freebsd-clang" or remove the -platform argument.
+
+qmake
+-----
+
+ - qmake now enables C++11 support by default if the compiler supports
+   it (unless the compiler defaults to C++14 or a later edition).
+   To disable this (not possible with Microsoft Visual Studio), add
+   "CONFIG -= c++11" to your .pro file. Note that Qt 5.7 requires C++11
+   support, so it is a good idea to ensure your code works with that
+   compiler setting.
+ - [Windows] The .prl files written by earlier versions of Qt cannot
+   be used any more. This will affect you if you depend on 3rd party
+   libraries which come with .prl files. Patch up QMAKE_PRL_TARGET to
+   contain the complete file name of the library, and replace any
+   /LIBPATH: in QMAKE_PRL_LIBS with -L.
+ - [Windows] QMake is now a lot stricter about what may appear in LIBS.
+   Use -L instead of the Windows-specific /LIBPATH. Put flags other
+   than -l and -L into QMAKE_LFLAGS.
+ - The library lookup has been simplified. This includes the removal of
+   support for the QMAKE_<lib>_SUFFIX variables, and the removal of
+   attempts to locate libraries under slightly different names than
+   specified.
+ - [Unix] QMAKE_POST_LINK steps of static libraries are now required
+   to operate on $(TARGET) in $(DESTDIR) instead of $$OUT_PWD.
+   This matches the Windows backends.
+ - Makespecs must now define QMAKE_{PREFIX,EXTENSION}_{SH,STATIC}LIB.
+
+
+Accessibility
+-------------
+
+ - [QTBUG-44479] We now report text attributes correctly on Linux, so
+   ORCA+F now works properly in QTextEdit and other text controls.
+
+Widgets
+-------
+
+ - [QTBUG-1049][QTBUG-2295][QTBUG-4532][QTBUG-18883][QTBUG-35148] The
+   tabs for the tabified docks can be moved by the user.
+
+QtTest
+------
+
+ - [QTBUG-47370] Crash/exception information is now logged to standard
+   output on Windows.
+
+****************************************************************************
+*                               Library                                    *
+****************************************************************************
+
+QtCore
+------
+
+ - Types in the Q_PROPERTY macro can now contain commas (for example,
+   QMap<Foo, Bar>)
+ - Added QVersionNumber.
+ - All generic containers (with the exception of QVarLengthArray, but
+   including QSharedPointer) destroy the previous state as part of a
+   move-assignment. Previously, they would dump it into the
+   right-hand-side object. Note that this is only true for the generic
+   containers. Other implicitly-shared types, as well as the non-generic
+   containers such as QString, QByteArray, etc. still swap the contents with
+   the right-hand-side object when move-assigned into, and for performance
+   reasons, this does not change in the foreseeable future.
+ - All containers (with the exception of QVarLengthArray, but including
+   QSharedPointer) are now nothrow_default_constructible,
+   nothrow_move_constructible, nothrow_move_assignable, and
+   nothrow-swappable.
+ - [QTBUG-25919] Added rbegin(), crbegin(), rend(), crend(), and
+   reverse_iterator and const_reverse_iterator typedefs to
+   QByteArray, QString, QList, QLinkedList, QVector, QVarLengthArray,
+   and QSet.
+ - [QTBUG-46026] Added the convenience constFirst() and constLast()
+   functions to QList and QVector.
+ - Added relational operators <, <=, >, >= to QList, QVector, and
+   QVarLengthArray if the element type supports operator<.
+ - Added qHash() overloads for QList, QVector, QLocale, QMatrix, QTransform,
+   QMimeType, QRegExp, QRegularExpression, and QUrlQuery.
+ - Unicode data updated to v8.0
+
+ - Logging:
+   * QT_LOGGING_RULES now supports multiple rules separated by semicolons
+   * Systems with syslog may now pass -syslog to configure to send logging
+     output to syslog.
+
+ - QCommandLineParser:
+   * [QTBUG-44298] Added support for hiding options from the --help output,
+     with QCommandLineOption::setHidden(true).
+   * Added parsing mode for options after arguments, to allow treating them
+     as more arguments.
+
+ - QDebug:
+   * How verbose a single debug output should be can now be fine-tuned by
+     setting a verbosity on the debug stream.
+   * When streaming QWindow, QScreen, QWidget instances to a debug stream
+     that has increased verbosity set, detailed information about
+     geometries, states etc. is printed.
+
+ - QDir:
+   * Added listSeparator().
+
+ - QHash/QMap:
+   * Added key iterators, accessible through keyBegin() and keyEnd().
+
+ - QLatin1String:
+   * Added default constructor.
+
+ - QLocale:
+   * [QTBUG-4044][QTBUG-3068] The C locale does not use group separators
+     to format numbers any more.
+   * [QTBUG-49031] Fixed a bug that caused QLocale::textDirection() to
+     always return Qt::LeftToRight and QLocale::script() to return
+     QLocale::AnyScript for the Windows system locale.
+
+ - QMap:
+   * Added const equal_range() overload.
+
+ - QMetaProperty:
+   * write() now resets the property if an empty QVariant is given, or set
+     a default constructed object if the property is not resettable.
+
+ - QPluginLoader:
+   * Fixed the search order of Qt plugins so that paths specified by the
+     QT_PLUGIN_PATH environment variable are searched before built-in
+     paths.
+
+ - QProcess:
+   * [QTBUG-47271] Fixed a bug that caused QProcess to launch a child
+     process on Unix even if the directory specified with
+     setWorkingDirectory did not exist.
+   * Deprecated QProcess::error() signal in favor of the new
+     QProcess::errorOccurred() signal.
+
+ - QProcessEnvironment:
+   * Fixed a bug in operator== involving different empty states.
+
+ - QSet:
+   * Added intersects().
+
+ - QSharedPointer:
+   * [QTBUG-49748] Fixed a problem that causes a compilation error
+     when constructing a QSharedPointer of a const type that derives
+     from QEnableSharedFromThis.
+
+ - QStorageInfo:
+   * Added QStorageInfo::blockSize(), which returns the optimal block size
+     for transferring data to and from the storage.
+
+ - QString:
+   * fromLatin1(), fromAscii(), fromUtf8() and fromLocal8Bit() now return a
+     null QString when called with a null QByteArray.
+   * Added insert(int, QStringRef), insert(int, const char*), and
+     insert(int, QByteArray) overloads.
+   * Added prepend(QStringRef) and prepend(const QChar *, int) overloads.
+   * resize() no longer shrinks the capacity. That means resize(0) now
+     reliably preserves capacity().
+
+ - QStringRef:
+   * Added truncate(int).
+
+ - QTemporaryDir:
+   * Added errorString() method that returns the string explaining why
+     creating the temporary directory failed.
+
+ - QTextStream:
+   * Can now stream QStringRef without converting to a QString first.
+
+ - QThread:
+   * [QTBUG-49870] Fixed a bug that would cause debug-mode applications to
+     live-lock on exit if they had a global static containing a QThread
+     that wasn't exited properly.
+
+ - QVariant:
+   * [QTBUG-40644] Fixed crash when setting a QVariant of a different type to
+     a property of a custom type by attempting to do a conversion instead.
+   * [QTBUG-37851] QVariant(QColor)::toString() now uses QColor::HexArgb format
+     when the alpha component is different from 1.
+
+ - QVector:
+   * [QTBUG-39293] resize() will no longer shrink the capacity. That means
+     resize(0) now reliably preserves capacity().
+
+ - QtAlgorithms:
+   * Added qFindFirstSetBit() and qFindLastSetBit().
+
+QtDBus
+------
+
+ - [QTBUG-14131] The QtDBus library now links directly to the libdbus-1
+   system library if it was detected at configure time. To force linking to
+   the library, pass option -dbus-linked to configure; to force dynamic
+   loading at runtime, use -dbus-runtime.
+
+QtGui
+-----
+
+ - [QTBUG-43674] Linux accessibility (using XCB) works for
+   applications launched as root.
+ - Added ReturnKeyType enum that emulates the native return key press on
+   different mobile platforms, to indicate actions such as search, move to
+   next field, and so on.
+
+ - Painting:
+   * Internal precision of solids and gradients is up to 16bit per color.
+
+ - QFont:
+   * [QTBUG-15214] QFont now serializes the capitalization setting.
+
+ - QGuiApplication:
+   * [QTBUG-47690] Fixed a regression where both sessionId and sessionKey were
+     empty on Windows.
+
+ - QIcon:
+   * [QTBUG-42109] Added the ability for QIcons to be marked as template images.
+     This allows end users to create QSystemTrayIcons that are properly
+     displayed as monochrome images on OS X, which is especially important
+     on Yosemite and above when Dark Mode is turned on.
+
+ - QKeySequence:
+   * Added qHash(QKeySequence).
+
+ - QTextLayout:
+   * Added QVector-based alternatives setFormat(), format(), and
+     clearFormat() to setAdditionalFormats(), additionalFormats(), and
+     clearAdditionalFormats(), resp.
+   * [QTBUG-41197] Fixed an uncommon rendering error with fonts containing
+     overlapping contours.
+   * [QTBUG-47547] Fixed some instances of missing glyphs when drawing large
+     fonts.
+   * [QTBUG-47547] Fixed problem where fallback fonts for text with certain
+     styles would be reported as unscalable.
+   * Freetype:
+     * [QTBUG-45963] Fixed a divide-by-zero exception when accessing bitmap
+       fonts.
+   * [QTBUG-50715] QTextLayout::glyphRuns() now returns united bounding
+     rects for glyph runs that are merged.
+
+ - OpenGL:
+   * [QTBUG-46161] Added QOpenGLExtraFunctions providing OpenGL ES 3.0 and
+     3.1 function wrappers in a cross-platform manner.
+   * [QTBUG-39235] Added support for multiple render targets in
+     QOpenGLFramebufferObject.
+   * [QTBUG-42444] Made QInputMethod's visible more accurate.
+
+QtNetwork
+---------
+
+ - QSslServer:
+   * In an SSL connection, the client socket now uses the server's cipher
+     preferences by default. This can be disabled using the QSslConfiguration.
+
+ - QUdpSocket:
+   * [QTBUG-47011] Fixed a bug that caused the QAbstractSocket::ShareAddress
+     option not to work on Linux.
+
+QtPlatformSupport
+-----------------
+
+ - QKdeTheme:
+   * Added support for KDE Plasma 5, which is also the default theme now.
+
+QtSql
+-----
+
+ - [QTBUG-3500] SSL support for MySQL database connections has been added.
+   Option CLIENT_SSL replaced by SSL_KEY, SSL_CERT, SSL_CA, SSL_CAPATH and
+   SSL_CIPHER, so that the keys, certificates and cipher can be specified.
+ - Improved performance when reading integer values from MySQL databases via
+   prepared statements.
+
+QtTest
+------
+
+ - [QTBUG-47370] A stack trace is output on standard error if a test
+   crashes.
+ - Added macros QTRY_VERIFY2_WITH_TIMEOUT() and QTRY_VERIFY2(), making it
+   possible to output a message after the timeout has expired.
+
+QtWidgets
+---------
+
+ - QComboBox:
+   * QComboBox::setView() no longer deletes the old view directly. It now
+     checks the ownership first.
+
+ - QListView:
+   * [QTBUG-37007] Horizontal scrolling with a vertical mouse wheel
+     is now possible.
+
+ - QMainWindow:
+   * Added GroupedDragging as a DockOption which allow users to drag all
+     the tabs together when dragging the title of a QDockWidget which is
+     tabbed with others.
+
+ - QSizePolicy:
+   * Added qHash(QSizePolicy).
+
+ - QTabBar:
+   * [QTBUG-45173][QTBUG-15128] Fixed moving tab when a stylesheet is
+     applied.
+
+ - QFontDialog:
+     * Added supportedSchemes property.
+
+****************************************************************************
+*                      Platform-specific Changes                           *
+****************************************************************************
+
+Android
+-------
+
+ - [QTBUG-38379] Stylus devices such as S Pen will generate QTabletEvents now.
+ - [QTBUG-40731] Implemented QInputMethod::keyboardRectangle.
+ - [QTBUG-45585] Fixed the opening of a local file using
+   QDesktopServices::openUrl().
+
+Windows
+-------
+
+ - [QTBUG-41309][QTBUG-41883][QTBUG-42410] Add a function to
+   QWindowsWindowFunctions to enable working around a limitation with
+   showing other top level windows while showing a fullscreen OpenGL-based
+   window.
+ - DirectWrite support is now the default if available.
+
+ - DirectWrite:
+   * [QTBUG-48546] Added differentiation between vertical hinting and no
+     hinting in DirectWrite font engine.
+   * [QTBUG-49562] Fixed clipping bug when rendering unhinted text with
+     grayscale antialiasing.
+   * [QTBUG-49562] Added transformation support to DirectWrite engine when
+     using grayscale antialiasing.
+   * [QTBUG-50009] Fixed transformed text when using the DirectWrite font
+     engine.
+
+ - Text:
+   * [QTBUG-47141] Made it possible to disable antialiasing for text when
+     drawing into images.
+   * [QTBUG-48546] Fixed uneven kerning for some fonts.
+
+X11/XCB
+-------
+
+ - [QTBUG-42985] In case there are no physical screens attached,
+   QGuiApplication::screens() and QGuiApplication::primaryScreen() will
+   now return a placeholder QScreen object.
+ - [QTBUG-49071] Fixed focusIn event on hide/show being not delivered.
+ - Harmonized input context selection. QT_IM_MODULE environment variable
+   is taken into account now.
+
+QPA
+---
+
+ - EGLFS/KMS:
+   * It is now possible to set the DPMS mode and get the current value for
+     each screen.
+
+ - WinRT:
+   * Windows Store apps are now composited inside a XAML container,
+     allowing for tighter integration with the native UI layer.
+   * Application status bar is visible by default now.
+
+****************************************************************************
+*                                Tools                                     *
+****************************************************************************
+
+configure & build system
+------------------------
+
+ - Qt's build system now detects whether the compiler supports C++14 and
+   experimental support for C++1z. If the compiler supports it, Qt is
+   compiled using that. This does not apply to user applications built
+   using qmake: those are still built with C++11 support only. To build
+   your application with C++14 support, add "CONFIG += c++14"
+   (similarly for C++1z) to your .pro file.
+ - [GCC][ELF] The Qt libraries now contain ELF versions.
+ - [QTBUG-48958][OS X] Configure with -no-rpath now yields dynamic Qt
+   libraries and frameworks with an absolute install name (based in
+   -libdir). This restores Qt 4 behavior.
+ - [MinGW] Fixed detection of DirectWrite.
+ - [iOS] The build process was significantly changed in several ways.
+   This doesn't matter unless you're doing Something Very Special.
+ - [Unix] -force-pkg-config is now just an alias for -pkg-config.
+ - [QTBUG-47840] Fixed pointer size detection when cross-building.
+ - [QTBUG-47920] GStreamer 1.0 is now preferred over 0.10.
+ - [QTBUG-48041][WinRT] Fixed -no-opengl not bailing out despite the
+   configuration causing a build error later on.
+ - [Linux] Qt is now built with relative rpaths, as was already the
+   case on OS X.
+ - [Windows] Configure now supports the -verbose option, like on Unix.
+ - [Unix] Added configure option to enable link-time code generation.
+ - Introduced the -optimized-tools option; supersedes -optimized-qmake.
+   Tools are by default not optimized in debug builds any more.
+ - Non-prefix builds don't have install targets any more.
+
+qmake
+-----
+
+ - By default, GNU extensions are now enabled with Clang, GCC, and ICC
+   even in C++11 and C++14 modes. To disable the GNU extensions, add
+   CONFIG+=strict_c++ to your .pro file.
+ - In addition to .qrc files, it is now possible to list standalone files
+   and directories, and collections of files in RESOURCES.
+ - [QTBUG-17533] Fixed dependency scan being confused by directly adjacent
+   string literals without intermediate whitespace. The parser also got more
+   C++ compliant and now understands C++11 raw strings.
+ - [QTBUG-21854] Deprecated DEPLOYMENT in favor of INSTALLS.
+ - [QTBUG-30813] Makefile output no longer contains implicit suffix rules,
+   as all sources are built using explicit rules.
+ - [QTBUG-36575] Fixed handling of QMAKE_OBJECTIVE_CFLAGS for Objective-C
+   (as opposed to Objective-C++). OBJECTIVE_SOURCES was obsoleted; use just
+   SOURCES. This behavior matches Xcode.
+ - [QTBUG-44184][Windows] Added RC_DEFINES to allow overriding DEFINES.
+   This is a workaround for incompatible quoting requirements of rc.exe
+   compared to cl.exe.
+ - [QTBUG-46910][Unix] Fixed infinite recursion with link_prl (the default)
+   and .la files in a .libs/ subdirectory.
+ - [QTBUG-47951] Fixed QMAKE_CXX/CROSS_COMPILE verification with ccache.
+ - [QTBUG-48287][Unix] Fixed race in debug_and_release builds of static libs.
+ - [QTBUG-48648][VS2013] Fixed creation of empty (and thus invalid)
+   <Dependencies> sections in manifest files.
+ - [QTBUG-49665][VS] Fixed shadow builds of subdirs projects.
+ - [QTBUG-50442][VS] Added support for precompiled headers without (or with
+   an uncommon) file extension.
+ - 'make check' targets will now extend QT_PLUGIN_PATH instead of
+   overwriting it.
+ - Fixed support for certain versions of (f)lex and yacc.
+ - [Darwin] Info.plist is now correctly placed also in plugin bundles.
+ - [Darwin] CONFIG+=plugin_bundle now actually creates Mach-O bundles.
+ - [Unix] Added support for paths relative to the target in QMAKE_RPATHDIR.
+ - [Unix] Support for CONFIG+=compile_libtool was removed. Use
+   CONFIG+=create_libtool and/or custom compilers instead.
+ - [Windows] Libraries coming with .prl files can now have non-standard file
+   extensions and a major version of zero.
+ - [WEC2013][VS] Fixed support for VS2013 SDKs.
+ - [MSys] Added workaround for MinGW-make's magic handling of paths.
+   Prepend @msyshack@ to INSTALL_ROOT to prevent MSys root prefixing.
diff --git a/doc/global/manifest-meta.qdocconf b/doc/global/manifest-meta.qdocconf
index c45470838aa..f535f5e2903 100644
--- a/doc/global/manifest-meta.qdocconf
+++ b/doc/global/manifest-meta.qdocconf
@@ -55,9 +55,7 @@ manifestmeta.highlighted.names      =   "QtQuick/Qt Quick Demo - Same Game" \
                                         "QtMultimedia/QML Video Shader Effects Example" \
                                         "QtCanvas3D/Planets Example" \
                                         "QtCanvas3D/Interactive Mobile Phone Example" \
-                                        "QtLocation/Map Viewer (QML)" \
-                                        "QtWebEngine/WebEngine Quick Nano Browser" \
-                                        "QtWebEngine/Markdown Editor Example"
+                                        "QtLocation/Map Viewer (QML)"
 
 manifestmeta.highlighted.attributes =   isHighlighted:true
 
diff --git a/doc/global/template/style/offline-simple.css b/doc/global/template/style/offline-simple.css
index b11cb6a137e..5d8ce5c37fd 100644
--- a/doc/global/template/style/offline-simple.css
+++ b/doc/global/template/style/offline-simple.css
@@ -1,11 +1,11 @@
 body {
-  font-size: 14px;
+  font-size: 10.5pt;
 }
 
 pre {
   background-color: #f0f0f0;
   font-family: Courier, monospace;
-  font-size: 15px;
+  font-size: 11pt;
   font-weight: 600;
   vertical-align: top;
   margin: 15px 85px 15px 35px;
@@ -41,7 +41,7 @@ a[href|="http://"], a[href|="https://"] {
 h1.title {
   margin-top: 30px;
   margin-left: 6px;
-  font-size: 32px;
+  font-size: 24pt;
   padding: 6px;
 }
 
@@ -52,7 +52,7 @@ h2, p.h2 {
 }
 
 h3 {
-  font-size: 16px;
+  font-size: 12pt;
   margin: 30px 0px 30px 6px;
 }
 
@@ -82,7 +82,7 @@ h3.fn, span.fn {
   padding: 5px;
   text-decoration: none;
   font-weight: 400;
-  font-size: 16px;
+  font-size: 12pt;
   margin: 45px 0px 0px 6px;
 }
 
@@ -107,7 +107,7 @@ table tr.odd {
 table.qmlname td {
   padding: 0px;
   margin-left: 6px;
-  font-size: 16px;
+  font-size: 12pt;
 }
 
 table.qmlname p .name,
@@ -125,12 +125,12 @@ h3.fn .name, h3.fn .type {
 }
 
 tr > td > pre {
-  font-size: 14px;
+  font-size: 10.5pt;
 }
 
 code {
   font-family: Courier, monospace;
-  font-size: 16px;
+  font-size: 12pt;
   font-weight: 400;
 }
 
@@ -167,7 +167,7 @@ td#buildversion {
 .footer, .footer p {
   padding: 5px 0px 5px 0px;
   margin: 45px 15px 5px 15px;
-  font-size: 10px;
+  font-size: 7.5pt;
   background-color: #cccccc;
 }
 
diff --git a/examples/network/torrent/mainwindow.cpp b/examples/network/torrent/mainwindow.cpp
index 2b87f712946..bfe221c1290 100644
--- a/examples/network/torrent/mainwindow.cpp
+++ b/examples/network/torrent/mainwindow.cpp
@@ -702,7 +702,7 @@ void TorrentView::dragMoveEvent(QDragMoveEvent *event)
 {
     // Accept file actions with a '.torrent' extension.
     QUrl url(event->mimeData()->text());
-    if (url.isValid() && url.scheme().toLower() == "file"
+    if (url.isValid() && url.scheme() == "file"
             && url.path().toLower().endsWith(".torrent"))
         event->acceptProposedAction();
 }
diff --git a/examples/widgets/mainwindows/application/mainwindow.cpp b/examples/widgets/mainwindows/application/mainwindow.cpp
index 86dfae166f3..861b908189d 100644
--- a/examples/widgets/mainwindows/application/mainwindow.cpp
+++ b/examples/widgets/mainwindows/application/mainwindow.cpp
@@ -59,6 +59,10 @@ MainWindow::MainWindow()
     connect(textEdit->document(), &QTextDocument::contentsChanged,
             this, &MainWindow::documentWasModified);
 
+    QGuiApplication::setFallbackSessionManagementEnabled(false);
+    connect(qApp, &QGuiApplication::commitDataRequest,
+            this, &MainWindow::commitData);
+
     setCurrentFile(QString());
     setUnifiedTitleAndToolBarOnMac(true);
 }
@@ -383,3 +387,15 @@ QString MainWindow::strippedName(const QString &fullFileName)
     return QFileInfo(fullFileName).fileName();
 }
 //! [49]
+
+void MainWindow::commitData(QSessionManager &manager)
+{
+    if (manager.allowsInteraction()) {
+        if (!maybeSave())
+            manager.cancel();
+    } else {
+        // Non-interactive: save without asking
+        if (textEdit->document()->isModified())
+            save();
+    }
+}
diff --git a/examples/widgets/mainwindows/application/mainwindow.h b/examples/widgets/mainwindows/application/mainwindow.h
index 08b4aa17f50..9712604125b 100644
--- a/examples/widgets/mainwindows/application/mainwindow.h
+++ b/examples/widgets/mainwindows/application/mainwindow.h
@@ -47,6 +47,7 @@ QT_BEGIN_NAMESPACE
 class QAction;
 class QMenu;
 class QPlainTextEdit;
+class QSessionManager;
 QT_END_NAMESPACE
 
 //! [0]
@@ -69,6 +70,7 @@ private slots:
     bool saveAs();
     void about();
     void documentWasModified();
+    void commitData(QSessionManager &);
 
 private:
     void createActions();
diff --git a/mkspecs/common/ghs-base.conf b/mkspecs/common/ghs-base.conf
new file mode 100644
index 00000000000..cd1e598942f
--- /dev/null
+++ b/mkspecs/common/ghs-base.conf
@@ -0,0 +1,39 @@
+#
+# This file is used as a basis for the following compilers:
+#
+# - The Green Hills Software compiler
+#
+
+QMAKE_COMPILER          = ghs
+
+QMAKE_CFLAGS           += --signed_fields --no_commons --diag_suppress=1,82,228,236,381,611,961,997,1795,1974
+QMAKE_CFLAGS_DEPS      += -MD
+QMAKE_CFLAGS_RELEASE   += -Ospeed -Olink -Omax -uvfd
+QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO += $$QMAKE_CFLAGS_RELEASE -g
+QMAKE_CFLAGS_DEBUG     += -g -Omaxdebug
+QMAKE_CFLAGS_SHLIB     +=
+QMAKE_CFLAGS_STATIC_LIB +=
+QMAKE_CFLAGS_APP       +=
+QMAKE_CFLAGS_YACC      += -Wno-unused -Wno-parentheses
+QMAKE_CFLAGS_HIDESYMS  +=
+
+QMAKE_CXXFLAGS         += $$QMAKE_CFLAGS --no_implicit_include --link_once_templates -non_shared --exceptions --new_outside_of_constructor
+QMAKE_CXXFLAGS_DEPS    += $$QMAKE_CFLAGS_DEPS
+QMAKE_CXXFLAGS_WARN_ON += $$QMAKE_CFLAGS_WARN_ON
+QMAKE_CXXFLAGS_WARN_OFF += $$QMAKE_CFLAGS_WARN_OFF
+QMAKE_CXXFLAGS_RELEASE += $$QMAKE_CFLAGS_RELEASE
+QMAKE_CXXFLAGS_RELEASE_WITH_DEBUGINFO += $$QMAKE_CFLAGS_RELEASE_WITH_DEBUGINFO
+QMAKE_CXXFLAGS_DEBUG   += $$QMAKE_CFLAGS_DEBUG
+QMAKE_CXXFLAGS_SHLIB   += $$QMAKE_CFLAGS_SHLIB
+QMAKE_CXXFLAGS_STATIC_LIB += $$QMAKE_CFLAGS_STATIC_LIB
+QMAKE_CXXFLAGS_APP     += $$QMAKE_CFLAGS_APP
+QMAKE_CXXFLAGS_YACC    += $$QMAKE_CFLAGS_YACC
+QMAKE_CXXFLAGS_HIDESYMS += $$QMAKE_CFLAGS_HIDESYMS
+QMAKE_CXXFLAGS_CXX11    += --c++11
+
+QMAKE_LFLAGS           += --no_commons -non_shared --link_once_templates --exceptions --stdle
+QMAKE_LFLAGS_RELEASE   += -Ospeed -Olink -uvfd
+QMAKE_LFLAGS_RELEASE_WITH_DEBUGINFO += $$QMAKE_LFLAGS_RELEASE -g
+
+QMAKE_LIBS_CORE         = -lposix -livfs -lsocket -lnet -ldl
+QMAKE_LIBS_GUI          = -lfbdev -lhiddev
diff --git a/mkspecs/common/ghs-integrity-armv7.conf b/mkspecs/common/ghs-integrity-armv7.conf
new file mode 100644
index 00000000000..f678edb9584
--- /dev/null
+++ b/mkspecs/common/ghs-integrity-armv7.conf
@@ -0,0 +1,17 @@
+#
+# Base qmake configuration for GHS on INTEGRITY
+#
+MAKEFILE_GENERATOR      = UNIX
+
+QMAKE_PLATFORM          = integrity
+
+include(unix.conf)
+
+include(ghs-base.conf)
+
+QMAKE_CC                = cxintarm -bsp $$(INTEGRITY_BSP) -os_dir $$(INTEGRITY_DIR) -non_shared
+QMAKE_CXX               = cxintarm -bsp $$(INTEGRITY_BSP) -os_dir $$(INTEGRITY_DIR) -non_shared
+QMAKE_LINK              = $$QMAKE_CXX
+QMAKE_AR                = $$QMAKE_CXX -archive -o
+
+load(qt_config)
diff --git a/mkspecs/common/ghs-integrity-x86.conf b/mkspecs/common/ghs-integrity-x86.conf
new file mode 100644
index 00000000000..5525b8cd172
--- /dev/null
+++ b/mkspecs/common/ghs-integrity-x86.conf
@@ -0,0 +1,17 @@
+#
+# Base qmake configuration for GHS on INTEGRITY
+#
+MAKEFILE_GENERATOR      = UNIX
+
+QMAKE_PLATFORM          = integrity
+
+include(unix.conf)
+
+include(ghs-base.conf)
+
+QMAKE_CC                = cxint86 -bsp $$(INTEGRITY_BSP) -os_dir $$(INTEGRITY_DIR) -non_shared
+QMAKE_CXX               = cxint86 -bsp $$(INTEGRITY_BSP) -os_dir $$(INTEGRITY_DIR) -non_shared
+QMAKE_LINK              = $$QMAKE_CXX
+QMAKE_AR                = $$QMAKE_CXX -archive -o
+
+load(qt_config)
diff --git a/mkspecs/common/integrity/qplatformdefs.h b/mkspecs/common/integrity/qplatformdefs.h
new file mode 100644
index 00000000000..c4cd5c0782a
--- /dev/null
+++ b/mkspecs/common/integrity/qplatformdefs.h
@@ -0,0 +1,100 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 Green Hills Software. All rights reserved.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the qmake spec of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef Q_INTEGRITY_PLATFORMDEFS_H
+#define Q_INTEGRITY_PLATFORMDEFS_H
+
+// Get Qt defines/settings
+
+#include "qglobal.h"
+
+#include <stdbool.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#define __STDC_CONSTANT_MACROS
+
+#include <pthread.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/select.h>
+
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+// INTEGRITY doesn't have the System V <sys/shm.h> header. This is not a standard
+// POSIX header, it's only documented in the Single UNIX Specification.
+// The preferred POSIX compliant way to share memory is to use the functions
+// in <sys/mman.h> that comply with the POSIX Real Time Interface (1003.1b).
+#include <sys/mman.h>
+#include <sys/socket.h>
+#include <sys/stat.h>
+#include <sys/wait.h>
+#include <netinet/in.h>
+#ifndef QT_NO_IPV6IFNAME
+#include <net/if.h>
+#endif
+
+// for htonl
+#include <arpa/inet.h>
+
+#define QT_SNPRINTF ::snprintf
+#define QT_VSNPRINTF ::vsnprintf
+
+// INTEGRITY doesn't have getpagesize()
+inline int getpagesize()
+{
+    return ::sysconf(_SC_PAGESIZE);
+}
+
+// geteuid() is only available with multi-process posix, but we do not want
+// to rely on it
+inline uid_t geteuid(void)
+{
+    return 0;
+}
+
+// getuid() is only available with multi-process posix, but we do not want
+// to rely on it
+inline uid_t getuid(void)
+{
+    return 0;
+}
+
+#include "../posix/qplatformdefs.h"
+#undef QT_OPEN_LARGEFILE
+#define QT_OPEN_LARGEFILE 0
+#define PATH_MAX 1024
+
+#endif // Q_QNX_PLATFORMDEFS_H
diff --git a/mkspecs/devices/linux-jetson-tk1-g++/qmake.conf b/mkspecs/devices/linux-jetson-tk1-g++/qmake.conf
new file mode 100644
index 00000000000..23957fe3cea
--- /dev/null
+++ b/mkspecs/devices/linux-jetson-tk1-g++/qmake.conf
@@ -0,0 +1,31 @@
+#
+# qmake configuration for the Jetson TK1 boards
+#
+# A typical configure line might look like:
+# configure \
+#   -device linux-jetson-tk1-g++ \
+#   -device-option CROSS_COMPILE=/opt/nvidia/toolchains/tegra-4.8.1-nv/usr/bin/arm-cortex_a15-linux-gnueabi/arm-cortex_a15-linux-gnueabi- \
+#   -sysroot /opt/nvidia/l4t/targetfs
+
+include(../common/linux_device_pre.conf)
+
+QMAKE_INCDIR += \
+    $$[QT_SYSROOT]/usr/include
+
+QMAKE_LIBDIR += \
+    $$[QT_SYSROOT]/usr/lib \
+    $$[QT_SYSROOT]/lib/arm-linux-gnueabihf \
+    $$[QT_SYSROOT]/usr/lib/arm-linux-gnueabihf
+
+QMAKE_LFLAGS += \
+    -Wl,-rpath-link,$$[QT_SYSROOT]/usr/lib \
+    -Wl,-rpath-link,$$[QT_SYSROOT]/usr/lib/arm-linux-gnueabihf \
+    -Wl,-rpath-link,$$[QT_SYSROOT]/lib/arm-linux-gnueabihf
+
+DISTRO_OPTS                  += hard-float
+COMPILER_FLAGS               += -mtune=cortex-a15 -march=armv7-a -mfpu=neon-vfpv4
+
+EGLFS_DEVICE_INTEGRATION = eglfs_kms_egldevice
+
+include(../common/linux_arm_device_post.conf)
+load(qt_config)
diff --git a/mkspecs/devices/linux-jetson-tk1-g++/qplatformdefs.h b/mkspecs/devices/linux-jetson-tk1-g++/qplatformdefs.h
new file mode 100644
index 00000000000..e927f750158
--- /dev/null
+++ b/mkspecs/devices/linux-jetson-tk1-g++/qplatformdefs.h
@@ -0,0 +1,40 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 3 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL3 included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 3 requirements
+** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 2.0 or (at your option) the GNU General
+** Public license version 3 or any later version approved by the KDE Free
+** Qt Foundation. The licenses are as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-2.0.html and
+** https://www.gnu.org/licenses/gpl-3.0.html.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "../../linux-g++/qplatformdefs.h"
diff --git a/mkspecs/features/benchmark.prf b/mkspecs/features/benchmark.prf
new file mode 100644
index 00000000000..bfae9227001
--- /dev/null
+++ b/mkspecs/features/benchmark.prf
@@ -0,0 +1 @@
+load(testcase)
diff --git a/mkspecs/features/default_post.prf b/mkspecs/features/default_post.prf
index cd8d8859aa9..e7e9a5bd87f 100644
--- a/mkspecs/features/default_post.prf
+++ b/mkspecs/features/default_post.prf
@@ -96,9 +96,16 @@ breakpad {
 }
 
 c++11|c++14|c++1z {
-    c++1z:       cxxstd = CXX1Z
-    else: c++14: cxxstd = CXX14
-    else:        cxxstd = CXX11
+    # Disable special compiler flags for host builds
+    !host_build|!cross_compile {
+        c++1z:       cxxstd = CXX1Z
+        else: c++14: cxxstd = CXX14
+        else:        cxxstd = CXX11
+    } else {
+        # Fall back to c++11, because since 5.7 c++11 is required everywhere,
+        # including host builds
+        cxxstd = CXX11
+    }
 
     # Check if we should disable the GNU extensions or not
     !strict_c++:!isEmpty(QMAKE_CXXFLAGS_GNU$$cxxstd): cxxstd = GNU$$cxxstd
diff --git a/mkspecs/features/java.prf b/mkspecs/features/java.prf
index 1b9754da8a7..54dced28650 100644
--- a/mkspecs/features/java.prf
+++ b/mkspecs/features/java.prf
@@ -2,7 +2,7 @@ TEMPLATE = lib
 android {
     API_VERSION_TO_USE = $$(ANDROID_API_VERSION)
     isEmpty(API_VERSION_TO_USE): API_VERSION_TO_USE = $$API_VERSION
-    isEmpty(API_VERSION_TO_USE): API_VERSION_TO_USE = android-10
+    isEmpty(API_VERSION_TO_USE): API_VERSION_TO_USE = android-16
 
     ANDROID_JAR_FILE = $$ANDROID_SDK_ROOT/platforms/$$API_VERSION_TO_USE/android.jar
     !exists($$ANDROID_JAR_FILE) {
diff --git a/mkspecs/features/qt.prf b/mkspecs/features/qt.prf
index 3258590d3b1..873f914610b 100644
--- a/mkspecs/features/qt.prf
+++ b/mkspecs/features/qt.prf
@@ -160,21 +160,8 @@ qt_module_deps = $$resolve_depends(qt_module_deps, "QT.")
         contains(qt_module_deps, core) {
     relative_qt_rpath:!isEmpty(QMAKE_REL_RPATH_BASE):contains(INSTALLS, target):\
             isEmpty(target.files):isEmpty(target.commands):isEmpty(target.extra) {
-        mac {
-            if(equals(TEMPLATE, app):app_bundle)|\
-                    if(equals(TEMPLATE, lib):plugin:plugin_bundle) {
-                ios:  binpath = $$target.path/$${TARGET}.app
-                else: binpath = $$target.path/$${TARGET}.app/Contents/MacOS
-            } else: equals(TEMPLATE, lib):!plugin:lib_bundle {
-                binpath = $$target.path/$${TARGET}.framework/Versions/Current
-            } else {
-                binpath = $$target.path
-            }
-        } else {
-            binpath = $$target.path
-        }
         # NOT the /dev property, as INSTALLS use host paths
-        QMAKE_RPATHDIR += $$relative_path($$[QT_INSTALL_LIBS], $$binpath)
+        QMAKE_RPATHDIR += $$relative_path($$[QT_INSTALL_LIBS], $$qtRelativeRPathBase())
     } else {
         QMAKE_RPATHDIR += $$[QT_INSTALL_LIBS/dev]
     }
diff --git a/mkspecs/features/qt_build_config.prf b/mkspecs/features/qt_build_config.prf
index 518fd93f045..2d437e7f910 100644
--- a/mkspecs/features/qt_build_config.prf
+++ b/mkspecs/features/qt_build_config.prf
@@ -52,6 +52,9 @@ QMAKE_DIR_REPLACE_SANE = PRECOMPILED_DIR OBJECTS_DIR MOC_DIR RCC_DIR UI_DIR
     unset(modpath)
 }
 
+# Apply extra compiler flags passed via configure last.
+CONFIG = qt_build_extra $$CONFIG
+
 # Don't actually try to install anything in non-prefix builds.
 # This is much easier and safer than making every single INSTALLS
 # assignment conditional.
@@ -72,6 +75,10 @@ CONFIG += \
     # However, testcases should be still built with exceptions.
     exceptions_off testcase_exceptions
 
+# Under Windows, this is neither necessary (transitive deps are automatically
+# resolved), nor functional (.res files end up in .prl files and break things).
+unix: CONFIG += explicitlib
+
 
 defineTest(qtBuildPart) {
     bp = $$eval($$upper($$section(_QMAKE_CONF_, /, -2, -2))_BUILD_PARTS)
diff --git a/mkspecs/features/qt_build_extra.prf b/mkspecs/features/qt_build_extra.prf
new file mode 100644
index 00000000000..378f5bbd7c4
--- /dev/null
+++ b/mkspecs/features/qt_build_extra.prf
@@ -0,0 +1,40 @@
+#
+#  W A R N I N G
+#  -------------
+#
+# This file is not part of the Qt API.  It exists purely as an
+# implementation detail.  It may change from version to version
+# without notice, or even be removed.
+#
+# We mean it.
+#
+
+equals(TEMPLATE, subdirs): return()
+
+# It's likely that these extra flags will be wrong for host builds,
+# and the bootstrapped tools usually don't need them anyway.
+host_build:force_bootstrap: return()
+
+# The headersclean check needs defines and includes even for
+# header-only modules.
+DEFINES += $$EXTRA_DEFINES
+INCLUDEPATH += $$EXTRA_INCLUDEPATH
+
+# The other flags are relevant only for actual libraries.
+equals(TEMPLATE, aux): return()
+
+LIBS += $$EXTRA_LIBS
+
+# Static libs need no rpaths
+static: return()
+
+for (rp, EXTRA_RPATHS) {
+    absrp = $$absolute_path($$rp, $$[QT_INSTALL_LIBS])
+    !isEqual(absrp, $$rp) {
+        isEmpty(QMAKE_REL_RPATH_BASE)|!contains(INSTALLS, target): \
+            rp = $$absrp
+        else: \
+            rp = $$relative_path($$absrp, $$qtRelativeRPathBase())
+    }
+    QMAKE_RPATHDIR += $$rp
+}
diff --git a/mkspecs/features/qt_common.prf b/mkspecs/features/qt_common.prf
index 07300842a05..c1c668aec81 100644
--- a/mkspecs/features/qt_common.prf
+++ b/mkspecs/features/qt_common.prf
@@ -84,9 +84,9 @@ warnings_are_errors:warning_clean {
             QMAKE_CXXFLAGS_WARN_ON += -Werror -ww177,1224,1478,1881 $$WERROR
         }
     } else:gcc:!clang:!intel_icc {
-        # GCC 4.6-4.9, 5.x
+        # GCC 4.6-4.9, 5.x, ...
         ver = $${QT_GCC_MAJOR_VERSION}.$${QT_GCC_MINOR_VERSION}
-        contains(ver, "(4\\.[6789]|5\\..)") {
+        contains(ver, "(4\\.[6789]|[5-9]\\..)") {
             QMAKE_CXXFLAGS_WARN_ON += -Werror -Wno-error=cpp -Wno-error=deprecated-declarations $$WERROR
 
             # GCC prints this bogus warning, after it has inlined a lot of code
diff --git a/mkspecs/features/qt_functions.prf b/mkspecs/features/qt_functions.prf
index 2756f90b01d..9c3414c6fcd 100644
--- a/mkspecs/features/qt_functions.prf
+++ b/mkspecs/features/qt_functions.prf
@@ -33,6 +33,19 @@ defineReplace(qt5LibraryTarget) {
    return($$LIBRARY_NAME)
 }
 
+defineReplace(qtRelativeRPathBase) {
+    darwin {
+        if(equals(TEMPLATE, app):app_bundle)|\
+                if(equals(TEMPLATE, lib):plugin:plugin_bundle) {
+            ios: return($$target.path/$${TARGET}.app)
+            return($$target.path/$${TARGET}.app/Contents/MacOS)
+        }
+        equals(TEMPLATE, lib):!plugin:lib_bundle: \
+            return($$target.path/$${TARGET}.framework/Versions/Current)
+    }
+    return($$target.path)
+}
+
 defineTest(qtAddLibrary) {
     warning("qtAddLibrary() is deprecated. Use QT+= instead.")
 
diff --git a/mkspecs/features/qt_module_pris.prf b/mkspecs/features/qt_module_pris.prf
index 5f5639a1cf8..9c453505430 100644
--- a/mkspecs/features/qt_module_pris.prf
+++ b/mkspecs/features/qt_module_pris.prf
@@ -10,7 +10,7 @@
 #
 
 load(qt_build_paths)
-force_independent|!isEmpty(MODULE_FWD_INCLUDES): \
+force_independent|split_incpath: \
     CONFIG += need_fwd_pri
 mod_work_pfx = $$MODULE_QMAKE_OUTDIR/mkspecs/modules
 need_fwd_pri: \
@@ -42,8 +42,11 @@ MODULE_FWD_PRI = $$mod_work_pfx/qt_lib_$${MODULE_ID}.pri
         module_libs = "\$\$QT_MODULE_HOST_LIB_BASE"
     else: \
         module_libs = "\$\$QT_MODULE_LIB_BASE"
-    !isEmpty(QT_PRIVATE): \
-        module_rundep = "QT.$${MODULE_ID}.run_depends = $$replace(QT_PRIVATE, -private$, _private)"
+    # In addition to the library's private deps, the private module's deps
+    # are logically runtime deps of the public module.
+    runtime_deps = $$QT_PRIVATE $$QT_FOR_PRIVATE
+    !isEmpty(runtime_deps): \
+        module_rundep = "QT.$${MODULE_ID}.run_depends = $$replace(runtime_deps, -private$, _private)"
     else: \
         module_rundep =
     module_build_type = v2
diff --git a/mkspecs/features/testcase.prf b/mkspecs/features/testcase.prf
index e6eace190e5..08ed00715d0 100644
--- a/mkspecs/features/testcase.prf
+++ b/mkspecs/features/testcase.prf
@@ -6,13 +6,16 @@ have_target {
 # qt_build_config tells us to re-enable exceptions here.
 testcase_exceptions: CONFIG += exceptions
 
-check.files                =
-check.path                 = .
+benchmark: type = benchmark
+else: type = check
+
+$${type}.files =
+$${type}.path = .
 
 # Add environment for non-installed builds. Do this first, so the
 # 'make' variable expansions don't end up in a batch file/script.
 QT_TOOL_NAME = target
-qtAddTargetEnv(check.commands, QT)
+qtAddTargetEnv($${type}.commands, QT)
 
 # If the test ends up in a different directory, we should cd to that directory.
 TESTRUN_CWD = $$DESTDIR
@@ -27,44 +30,44 @@ debug_and_release:debug_and_release_target {
 }
 
 # Allow for a custom test runner script
-check.commands += $(TESTRUNNER)
+$${type}.commands += $(TESTRUNNER)
 
 unix {
     isEmpty(TEST_TARGET_DIR): TEST_TARGET_DIR = .
 
     app_bundle: \
-        check.commands += $${TEST_TARGET_DIR}/$(QMAKE_TARGET).app/Contents/MacOS/$(QMAKE_TARGET)
+        $${type}.commands += $${TEST_TARGET_DIR}/$(QMAKE_TARGET).app/Contents/MacOS/$(QMAKE_TARGET)
     else: \
-        check.commands += $${TEST_TARGET_DIR}/$(QMAKE_TARGET)
+        $${type}.commands += $${TEST_TARGET_DIR}/$(QMAKE_TARGET)
 } else {
     # Windows
     !isEmpty(TEST_TARGET_DIR): TEST_TARGET_DIR = $${TEST_TARGET_DIR}$${QMAKE_DIR_SEP}
-    check.commands += $${TEST_TARGET_DIR}$(TARGET)
+    $${type}.commands += $${TEST_TARGET_DIR}$(TARGET)
 }
 
 # Allow for custom arguments to tests
-check.commands += $(TESTARGS)
+$${type}.commands += $(TESTARGS)
 
 !isEmpty(TESTRUN_CWD):!contains(TESTRUN_CWD, ^\\./?): \
-    check.commands = cd $$shell_path($$TESTRUN_CWD) && $$check.commands
+    $${type}.commands = cd $$shell_path($$TESTRUN_CWD) && $$eval($${type}.commands)
 
 # If the test is marked as insignificant, discard the exit code
-insignificant_test:check.commands = -$${check.commands}
+insignificant_test: $${type}.commands = -$$eval($${type}.commands)
 
-QMAKE_EXTRA_TARGETS *= check
+QMAKE_EXTRA_TARGETS *= $${type}
 
 isEmpty(BUILDS)|build_pass {
-    check.depends = first
+    $${type}.depends = first
 } else {
     # For exclusive builds, only run the test once.
-    check.CONFIG = recursive
-    check.target = check_all
-    check.recurse_target = check
-    check.commands =
+    $${type}.CONFIG = recursive
+    $${type}.target = $${type}_all
+    $${type}.recurse_target = $${type}
+    $${type}.commands =
 
-    check_first.depends = $$eval($$first(BUILDS).target)-check
-    check_first.target = check
-    QMAKE_EXTRA_TARGETS += check_first
+    $${type}_first.depends = $$eval($$first(BUILDS).target)-$${type}
+    $${type}_first.target = $${type}
+    QMAKE_EXTRA_TARGETS += $${type}_first
 }
 
 !no_testcase_installs:!contains(INSTALLS, target) {
diff --git a/mkspecs/features/testcase_targets.prf b/mkspecs/features/testcase_targets.prf
index e9b107735a0..16ec6a9f0d4 100644
--- a/mkspecs/features/testcase_targets.prf
+++ b/mkspecs/features/testcase_targets.prf
@@ -7,3 +7,13 @@
         check.depends = first # `make check' implies build
     QMAKE_EXTRA_TARGETS += check
 }
+
+# ... and the same for benchmarks, too.
+!contains(QMAKE_EXTRA_TARGETS, benchmark) {
+    contains(TEMPLATE, subdirs): \
+        prepareRecursiveTarget(benchmark)
+    else: \
+        benchmark.depends = first # `make benchmark' implies build
+    QMAKE_EXTRA_TARGETS += benchmark
+}
+
diff --git a/mkspecs/integrity-armv7/qmake.conf b/mkspecs/integrity-armv7/qmake.conf
new file mode 100644
index 00000000000..c2d850b8b43
--- /dev/null
+++ b/mkspecs/integrity-armv7/qmake.conf
@@ -0,0 +1,8 @@
+#
+# qmake configuration for INTEGRITY armv7 targets
+#
+
+include(../common/ghs-integrity-armv7.conf)
+
+DEFINES += QT_NO_CLIPBOARD
+DEFINES += QT_STATICPLUGIN
diff --git a/mkspecs/integrity-armv7/qplatformdefs.h b/mkspecs/integrity-armv7/qplatformdefs.h
new file mode 100644
index 00000000000..55afd0c3c7b
--- /dev/null
+++ b/mkspecs/integrity-armv7/qplatformdefs.h
@@ -0,0 +1,39 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 Green Hills Software. All rights reserved.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the qmake spec of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPLATFORMDEFS_H
+#define QPLATFORMDEFS_H
+
+#include "../common/integrity/qplatformdefs.h"
+
+#endif // QPLATFORMDEFS_H
diff --git a/mkspecs/integrity-x86/qmake.conf b/mkspecs/integrity-x86/qmake.conf
new file mode 100644
index 00000000000..e70b54652a5
--- /dev/null
+++ b/mkspecs/integrity-x86/qmake.conf
@@ -0,0 +1,9 @@
+#
+# qmake configuration for INTEGRITY x86 32-bit targets
+#
+
+include(../common/ghs-integrity-x86.conf)
+
+QMAKE_CFLAGS += -cpu=Corei
+DEFINES += QT_NO_CLIPBOARD
+DEFINES += QT_STATICPLUGIN
diff --git a/mkspecs/integrity-x86/qplatformdefs.h b/mkspecs/integrity-x86/qplatformdefs.h
new file mode 100644
index 00000000000..55afd0c3c7b
--- /dev/null
+++ b/mkspecs/integrity-x86/qplatformdefs.h
@@ -0,0 +1,39 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 Green Hills Software. All rights reserved.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the qmake spec of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QPLATFORMDEFS_H
+#define QPLATFORMDEFS_H
+
+#include "../common/integrity/qplatformdefs.h"
+
+#endif // QPLATFORMDEFS_H
diff --git a/qmake/generators/unix/unixmake.cpp b/qmake/generators/unix/unixmake.cpp
index f062605dd4f..80a62a1cc28 100644
--- a/qmake/generators/unix/unixmake.cpp
+++ b/qmake/generators/unix/unixmake.cpp
@@ -564,7 +564,7 @@ UnixMakefileGenerator::defaultInstall(const QString &t)
                 dst = escapeFilePath(filePrefixRoot(root, targetdir + src.section('/', -1)));
         if(!ret.isEmpty())
             ret += "\n\t";
-        ret += "-$(INSTALL_FILE) " + escapeFilePath(src) + ' ' + dst;
+        ret += "-$(INSTALL_FILE) " + escapeFilePath(Option::fixPathToTargetOS(src, false)) + ' ' + dst;
         if(!uninst.isEmpty())
             uninst.append("\n\t");
         uninst.append("-$(DEL_FILE) " + dst);
diff --git a/qmake/generators/win32/msvc_nmake.cpp b/qmake/generators/win32/msvc_nmake.cpp
index 6f58a9887ae..9e1af054149 100644
--- a/qmake/generators/win32/msvc_nmake.cpp
+++ b/qmake/generators/win32/msvc_nmake.cpp
@@ -226,12 +226,9 @@ void NmakeMakefileGenerator::writeSubMakeCall(QTextStream &t, const QString &cal
 
 QString NmakeMakefileGenerator::defaultInstall(const QString &t)
 {
-    if((t != "target" && t != "dlltarget") ||
-       (t == "dlltarget" && (project->first("TEMPLATE") != "lib" || !project->isActiveConfig("shared"))) ||
-        project->first("TEMPLATE") == "subdirs")
-       return QString();
-
     QString ret = Win32MakefileGenerator::defaultInstall(t);
+    if (ret.isEmpty())
+        return ret;
 
     const QString root = installRoot();
     ProStringList &uninst = project->values(ProKey(t + ".uninstall"));
diff --git a/qmake/library/qmakeparser.cpp b/qmake/library/qmakeparser.cpp
index 01d9c26e01a..2a481031470 100644
--- a/qmake/library/qmakeparser.cpp
+++ b/qmake/library/qmakeparser.cpp
@@ -275,7 +275,8 @@ void QMakeParser::putHashStr(ushort *&pTokPtr, const ushort *buf, uint len)
     *tokPtr++ = (ushort)hash;
     *tokPtr++ = (ushort)(hash >> 16);
     *tokPtr++ = (ushort)len;
-    memcpy(tokPtr, buf, len * 2);
+    if (len) // buf may be nullptr; don't pass that to memcpy (-> undefined behavior)
+        memcpy(tokPtr, buf, len * 2);
     pTokPtr = tokPtr + len;
 }
 
diff --git a/src/3rdparty/harfbuzz-ng/harfbuzz-ng.pro b/src/3rdparty/harfbuzz-ng/harfbuzz-ng.pro
index edfc0e7954d..163842e8fc3 100644
--- a/src/3rdparty/harfbuzz-ng/harfbuzz-ng.pro
+++ b/src/3rdparty/harfbuzz-ng/harfbuzz-ng.pro
@@ -7,8 +7,12 @@ CONFIG += \
 
 load(qt_helper_lib)
 
+# built-in shapers list configuration:
+SHAPERS += opentype       # HB's main shaper; enabling it should be enough most of the time
+mac: SHAPERS += coretext  # native shaper on OSX/iOS; could be used alone to handle both OT and AAT fonts
+
 DEFINES += HAVE_CONFIG_H
-DEFINES += HAVE_OT HB_NO_UNICODE_FUNCS HB_DISABLE_DEPRECATED
+DEFINES += HB_NO_UNICODE_FUNCS HB_DISABLE_DEPRECATED
 
 # platform/compiler specific definitions
 DEFINES += HAVE_ATEXIT
@@ -78,57 +82,59 @@ HEADERS += \
     $$PWD/src/hb-unicode.h \
     $$PWD/src/hb-version.h
 
-# Open Type
-SOURCES += \
-    $$PWD/src/hb-ot-font.cc \
-    $$PWD/src/hb-ot-layout.cc \
-    $$PWD/src/hb-ot-map.cc \
-    $$PWD/src/hb-ot-shape.cc \
-    $$PWD/src/hb-ot-shape-complex-arabic.cc \
-    $$PWD/src/hb-ot-shape-complex-default.cc \
-    $$PWD/src/hb-ot-shape-complex-hangul.cc \
-    $$PWD/src/hb-ot-shape-complex-hebrew.cc \
-    $$PWD/src/hb-ot-shape-complex-indic.cc \
-    $$PWD/src/hb-ot-shape-complex-indic-table.cc \
-    $$PWD/src/hb-ot-shape-complex-myanmar.cc \
-    $$PWD/src/hb-ot-shape-complex-thai.cc \
-    $$PWD/src/hb-ot-shape-complex-tibetan.cc \
-    $$PWD/src/hb-ot-shape-complex-use.cc \
-    $$PWD/src/hb-ot-shape-complex-use-table.cc \
-    $$PWD/src/hb-ot-shape-fallback.cc \
-    $$PWD/src/hb-ot-shape-normalize.cc
+contains(SHAPERS, opentype) {
+    DEFINES += HAVE_OT
 
-HEADERS += \
-    $$PWD/src/hb-ot-layout-common-private.hh \
-    $$PWD/src/hb-ot-layout-gdef-table.hh \
-    $$PWD/src/hb-ot-layout-gpos-table.hh \
-    $$PWD/src/hb-ot-layout-gsubgpos-private.hh \
-    $$PWD/src/hb-ot-layout-gsub-table.hh \
-    $$PWD/src/hb-ot-layout-jstf-table.hh \
-    $$PWD/src/hb-ot-layout-private.hh \
-    $$PWD/src/hb-ot-map-private.hh \
-    $$PWD/src/hb-ot-shape-complex-arabic-fallback.hh \
-    $$PWD/src/hb-ot-shape-complex-arabic-private.hh \
-    $$PWD/src/hb-ot-shape-complex-arabic-table.hh \
-    $$PWD/src/hb-ot-shape-complex-indic-machine.hh \
-    $$PWD/src/hb-ot-shape-complex-indic-private.hh \
-    $$PWD/src/hb-ot-shape-complex-myanmar-machine.hh \
-    $$PWD/src/hb-ot-shape-complex-private.hh \
-    $$PWD/src/hb-ot-shape-complex-use-machine.hh \
-    $$PWD/src/hb-ot-shape-complex-use-private.hh \
-    $$PWD/src/hb-ot-shape-fallback-private.hh \
-    $$PWD/src/hb-ot-shape-normalize-private.hh \
-    $$PWD/src/hb-ot-shape-private.hh
+    SOURCES += \
+        $$PWD/src/hb-ot-font.cc \
+        $$PWD/src/hb-ot-layout.cc \
+        $$PWD/src/hb-ot-map.cc \
+        $$PWD/src/hb-ot-shape.cc \
+        $$PWD/src/hb-ot-shape-complex-arabic.cc \
+        $$PWD/src/hb-ot-shape-complex-default.cc \
+        $$PWD/src/hb-ot-shape-complex-hangul.cc \
+        $$PWD/src/hb-ot-shape-complex-hebrew.cc \
+        $$PWD/src/hb-ot-shape-complex-indic.cc \
+        $$PWD/src/hb-ot-shape-complex-indic-table.cc \
+        $$PWD/src/hb-ot-shape-complex-myanmar.cc \
+        $$PWD/src/hb-ot-shape-complex-thai.cc \
+        $$PWD/src/hb-ot-shape-complex-tibetan.cc \
+        $$PWD/src/hb-ot-shape-complex-use.cc \
+        $$PWD/src/hb-ot-shape-complex-use-table.cc \
+        $$PWD/src/hb-ot-shape-fallback.cc \
+        $$PWD/src/hb-ot-shape-normalize.cc
 
-HEADERS += \
-    $$PWD/src/hb-ot.h \
-    $$PWD/src/hb-ot-font.h \
-    $$PWD/src/hb-ot-layout.h \
-    $$PWD/src/hb-ot-shape.h \
-    $$PWD/src/hb-ot-tag.h
+    HEADERS += \
+        $$PWD/src/hb-ot-layout-common-private.hh \
+        $$PWD/src/hb-ot-layout-gdef-table.hh \
+        $$PWD/src/hb-ot-layout-gpos-table.hh \
+        $$PWD/src/hb-ot-layout-gsubgpos-private.hh \
+        $$PWD/src/hb-ot-layout-gsub-table.hh \
+        $$PWD/src/hb-ot-layout-jstf-table.hh \
+        $$PWD/src/hb-ot-layout-private.hh \
+        $$PWD/src/hb-ot-map-private.hh \
+        $$PWD/src/hb-ot-shape-complex-arabic-fallback.hh \
+        $$PWD/src/hb-ot-shape-complex-arabic-private.hh \
+        $$PWD/src/hb-ot-shape-complex-arabic-table.hh \
+        $$PWD/src/hb-ot-shape-complex-indic-machine.hh \
+        $$PWD/src/hb-ot-shape-complex-indic-private.hh \
+        $$PWD/src/hb-ot-shape-complex-myanmar-machine.hh \
+        $$PWD/src/hb-ot-shape-complex-private.hh \
+        $$PWD/src/hb-ot-shape-complex-use-machine.hh \
+        $$PWD/src/hb-ot-shape-complex-use-private.hh \
+        $$PWD/src/hb-ot-shape-fallback-private.hh \
+        $$PWD/src/hb-ot-shape-normalize-private.hh \
+        $$PWD/src/hb-ot-shape-private.hh
 
-mac {
-    # Apple Advanced Typography
+    HEADERS += \
+        $$PWD/src/hb-ot.h \
+        $$PWD/src/hb-ot-font.h \
+        $$PWD/src/hb-ot-layout.h \
+        $$PWD/src/hb-ot-shape.h \
+        $$PWD/src/hb-ot-tag.h
+}
+
+contains(SHAPERS, coretext) {
     DEFINES += HAVE_CORETEXT
 
     SOURCES += \
diff --git a/src/3rdparty/libpng/ANNOUNCE b/src/3rdparty/libpng/ANNOUNCE
index 9f1b6658342..4dae783b559 100644
--- a/src/3rdparty/libpng/ANNOUNCE
+++ b/src/3rdparty/libpng/ANNOUNCE
@@ -1,4 +1,4 @@
-Libpng 1.6.19 - November 12, 2015
+Libpng 1.6.20 - December 3, 2015
 
 This is a public release of libpng, intended for use in production codes.
 
@@ -7,104 +7,41 @@ Files available for download:
 Source files with LF line endings (for Unix/Linux) and with a
 "configure" script
 
-   libpng-1.6.19.tar.xz (LZMA-compressed, recommended)
-   libpng-1.6.19.tar.gz
+   libpng-1.6.20.tar.xz (LZMA-compressed, recommended)
+   libpng-1.6.20.tar.gz
 
 Source files with CRLF line endings (for Windows), without the
 "configure" script
 
-   lpng1619.7z  (LZMA-compressed, recommended)
-   lpng1619.zip
+   /scratch/glennrp/Libpng16/lpng1620.7z  (LZMA-compressed, recommended)
+   /scratch/glennrp/Libpng16/lpng1620.zip
 
 Other information:
 
-   libpng-1.6.19-README.txt
-   libpng-1.6.19-LICENSE.txt
-   libpng-1.6.19-*.asc (armored detached GPG signatures)
+   libpng-1.6.20-README.txt
+   libpng-1.6.20-LICENSE.txt
+   libpng-1.6.20-*.asc (armored detached GPG signatures)
 
-Changes since the last public release (1.6.18):
-
-  Updated obsolete information about the simplified API macros in the
-    manual pages (Bug report by Arc Riley).
-  Avoid potentially dereferencing NULL info_ptr in png_info_init_3().
-  Rearranged png.h to put the major sections in the same order as
-    in libpng17.
-  Eliminated unused PNG_COST_SHIFT, PNG_WEIGHT_SHIFT, PNG_COST_FACTOR, and
-    PNG_WEIGHT_FACTOR macros.
-  Suppressed some warnings from the Borland C++ 5.5.1/5.82 compiler
-    (Bug report by Viktor Szakats).  Several warnings remain and are
-    unavoidable, where we test for overflow.
-  Fixed potential leak of png_pixels in contrib/pngminus/pnm2png.c
-  Fixed uninitialized variable in contrib/gregbook/rpng2-x.c
-  Moved config.h.in~ from the "libpng_autotools_files" list to the
-    "libpng_autotools_extra" list in autogen.sh because it was causing a
-    false positive for missing files (bug report by Robert C. Seacord).
-  Removed unreachable "break" statements in png.c, pngread.c, and pngrtran.c
-    to suppress clang warnings (Bug report by Viktor Szakats).
-  Fixed some bad links in the man page.
-  Changed "n bit" to "n-bit" in comments.
-  Added signed/unsigned 16-bit safety net. This removes the dubious
-    0x8000 flag definitions on 16-bit systems. They aren't supported
-    yet the defs *probably* work, however it seems much safer to do this
-    and be advised if anyone, contrary to advice, is building libpng 1.6
-    on a 16-bit system. It also adds back various switch default clauses
-    for GCC; GCC errors out if they are not present (with an appropriately
-    high level of warnings).
-  Safely convert num_bytes to a png_byte in png_set_sig_bytes() (Robert
-    Seacord).
-  Fixed the recently reported 1's complement security issue by replacing
-    the value that is illegal in the PNG spec, in both signed and unsigned
-    values, with 0. Illegal unsigned values (anything greater than or equal
-    to  0x80000000) can still pass through, but since these are not illegal
-    in ANSI-C (unlike 0x80000000 in the signed case) the checking that
-    occurs later can catch them (John Bowler).
-  Fixed png_save_int_32 when int is not 2's complement (John Bowler).
-  Updated libpng16 with all the recent test changes from libpng17,
-    including changes to pngvalid.c to ensure that the original,
-    distributed, version of contrib/visupng/cexcept.h can be used
-    (John Bowler).
-  pngvalid contains the correction to the use of SAVE/STORE_
-    UNKNOWN_CHUNKS; a bug revealed by changes in libpng 1.7. More
-    tests contain the --strict option to detect warnings and the
-    pngvalid-standard test has been corrected so that it does not
-    turn on progressive-read. There is a separate test which does
-    that. (John Bowler)
-  Also made some signed/unsigned fixes.
-  Make pngstest error limits version specific. Splitting the machine
-    generated error structs out to a file allows the values to be updated
-    without changing pngstest.c itself. Since libpng 1.6 and 1.7 have
-    slightly different error limits this simplifies maintenance. The
-    makepngs.sh script has also been updated to more accurately reflect
-    current problems in libpng 1.7 (John Bowler).
-  Incorporated new test PNG files into make check.  tests/pngstest-*
-    are changed so that the new test files are divided into 8 groups by
-    gamma and alpha channel.  These tests have considerably better code
-    and pixel-value coverage than contrib/pngsuite; however,coverage is
-    still incomplete (John Bowler).
-  Removed the '--strict' in 1.6 because of the double-gamma-correction
-    warning, updated pngstest-errors.h for the errors detected with the
-    new contrib/testspngs PNG test files (John Bowler).
-  Worked around rgb-to-gray issues in libpng 1.6.  The previous
-    attempts to ignore the errors in the code aren't quite enough to
-    deal with the 'channel selection' encoding added to libpng 1.7; abort.
-  Fixed 'pow' macros in pngvalid.c. It is legal for 'pow' to be a
-    macro, therefore the argument list cannot contain preprocessing
-    directives.  Make sure pow is a function where this happens. This is
-    a minimal safe fix, the issue only arises in non-performance-critical
-    code (bug report by Curtis Leach, fix by John Bowler).
-  Added sPLT support to pngtest.c
-  Prevent setting or writing over-length PLTE chunk (Cosmin Truta).
-  Silently truncate over-length PLTE chunk while reading.
-  Libpng incorrectly calculated the output rowbytes when the application
-    decreased either the number of channels or the bit depth (or both) in
-    a user transform.  This was safe; libpng overallocated buffer space
-   (potentially by quite a lot; up to 4 times the amount required) but,
-   from 1.5.4 on, resulted in a png_error (John Bowler).
-  Fixed some inconsequential cut-and-paste typos in png_set_cHRM_XYZ_fixed().
-  Clarified COPYRIGHT information to state explicitly that versions
-    are derived from previous versions.
-  Removed much of the long list of previous versions from png.h and
-    libpng.3.
+Changes since the last public release (1.6.19):
+  Avoid potential pointer overflow/underflow in png_handle_sPLT() and
+    png_handle_pCAL() (Bug report by John Regehr).
+  Fixed incorrect implementation of png_set_PLTE() that uses png_ptr
+    not info_ptr, that left png_set_PLTE() open to the CVE-2015-8126
+    vulnerability.
+  Backported tests from libpng-1.7.0beta69.
+  Fixed an error in handling of bad zlib CMINFO field in pngfix, found by
+    American Fuzzy Lop, reported by Brian Carpenter.  inflate() doesn't
+    immediately fault a bad CMINFO field; instead a 'too far back' error
+    happens later (at least some times).  pngfix failed to limit CMINFO to
+    the allowed values but then assumed that window_bits was in range,
+    triggering an assert. The bug is mostly harmless; the PNG file cannot
+    be fixed.
+  In libpng 1.6 zlib initialization was changed to use the window size
+    in the zlib stream, not a fixed value. This causes some invalid images,
+    where CINFO is too large, to display 'correctly' if the rest of the
+    data is valid.  This provides a workaround for zlib versions where the
+    error arises (ones that support the API change to use the window size
+    in the stream).
 
 Send comments/corrections/commendations to png-mng-implement at lists.sf.net
 (subscription required; visit
diff --git a/src/3rdparty/libpng/CHANGES b/src/3rdparty/libpng/CHANGES
index 2e4d2bb292c..28094fd26cb 100644
--- a/src/3rdparty/libpng/CHANGES
+++ b/src/3rdparty/libpng/CHANGES
@@ -5409,11 +5409,43 @@ Version 1.6.19rc03 [November 3, 2015]
 
 Version 1.6.19rc04 [November 5, 2015]
   Fixed new bug with CRC error after reading an over-length palette
-    (bug report by Cosmin Truta).
+    (bug report by Cosmin Truta) (CVE-2015-8126).
 
 Version 1.6.19 [November 12, 2015]
   Cleaned up coding style in png_handle_PLTE().
 
+Version 1.6.20beta01 [November 20, 2015]
+  Avoid potential pointer overflow/underflow in png_handle_sPLT() and
+    png_handle_pCAL() (Bug report by John Regehr).
+
+Version 1.6.20beta02 [November 23, 2015]
+  Fixed incorrect implementation of png_set_PLTE() that uses png_ptr
+    not info_ptr, that left png_set_PLTE() open to the CVE-2015-8126
+    vulnerability.
+
+Version 1.6.20beta03 [November 24, 2015]
+  Backported tests from libpng-1.7.0beta69.
+
+Version 1.6.20rc01 [November 26, 2015]
+  Fixed an error in handling of bad zlib CMINFO field in pngfix, found by
+    American Fuzzy Lop, reported by Brian Carpenter.  inflate() doesn't
+    immediately fault a bad CMINFO field; instead a 'too far back' error
+    happens later (at least some times).  pngfix failed to limit CMINFO to
+    the allowed values but then assumed that window_bits was in range,
+    triggering an assert. The bug is mostly harmless; the PNG file cannot
+    be fixed.
+
+Version 1.6.20rc02 [November 29, 2015]
+  In libpng 1.6 zlib initialization was changed to use the window size
+    in the zlib stream, not a fixed value. This causes some invalid images,
+    where CINFO is too large, to display 'correctly' if the rest of the
+    data is valid.  This provides a workaround for zlib versions where the
+    error arises (ones that support the API change to use the window size
+    in the stream).
+
+Version 1.6.20 [December 3, 2015]
+  No changes.
+
 Send comments/corrections/commendations to png-mng-implement at lists.sf.net
 (subscription required; visit
 https://lists.sourceforge.net/lists/listinfo/png-mng-implement
diff --git a/src/3rdparty/libpng/LICENSE b/src/3rdparty/libpng/LICENSE
index 11f6ffe5db4..82dbe117f6d 100644
--- a/src/3rdparty/libpng/LICENSE
+++ b/src/3rdparty/libpng/LICENSE
@@ -10,7 +10,7 @@ this sentence.
 
 This code is released under the libpng license.
 
-libpng versions 1.0.7, July 1, 2000, through 1.6.19, November 12, 2015, are
+libpng versions 1.0.7, July 1, 2000, through 1.6.20, December 3, 2015, are
 Copyright (c) 2000-2002, 2004, 2006-2015 Glenn Randers-Pehrson, are
 derived from libpng-1.0.6, and are distributed according to the same
 disclaimer and license as libpng-1.0.6 with the following individuals
@@ -109,4 +109,4 @@ the additional disclaimers inserted at version 1.0.7.
 
 Glenn Randers-Pehrson
 glennrp at users.sourceforge.net
-November 12, 2015
+December 3, 2015
diff --git a/src/3rdparty/libpng/README b/src/3rdparty/libpng/README
index 17484e0fd78..59f1f918ae2 100644
--- a/src/3rdparty/libpng/README
+++ b/src/3rdparty/libpng/README
@@ -1,4 +1,4 @@
-README for libpng version 1.6.19 - November 12, 2015 (shared library 16.0)
+README for libpng version 1.6.20 - December 3, 2015 (shared library 16.0)
 See the note about version numbers near the top of png.h
 
 See INSTALL for instructions on how to install libpng.
diff --git a/src/3rdparty/libpng/libpng-manual.txt b/src/3rdparty/libpng/libpng-manual.txt
index bc7a441cf28..87eeb2b5837 100644
--- a/src/3rdparty/libpng/libpng-manual.txt
+++ b/src/3rdparty/libpng/libpng-manual.txt
@@ -1,6 +1,6 @@
 libpng-manual.txt - A description on how to use and modify libpng
 
- libpng version 1.6.19 - November 12, 2015
+ libpng version 1.6.20 - December 3, 2015
  Updated and distributed by Glenn Randers-Pehrson
  <glennrp at users.sourceforge.net>
  Copyright (c) 1998-2015 Glenn Randers-Pehrson
@@ -11,7 +11,7 @@ libpng-manual.txt - A description on how to use and modify libpng
 
  Based on:
 
- libpng versions 0.97, January 1998, through 1.6.19 - November 12, 2015
+ libpng versions 0.97, January 1998, through 1.6.20 - December 3, 2015
  Updated and distributed by Glenn Randers-Pehrson
  Copyright (c) 1998-2015 Glenn Randers-Pehrson
 
@@ -2960,6 +2960,7 @@ width, height, bit_depth, and color_type must be the same in each call.
                      (array of png_color)
     num_palette    - number of entries in the palette
 
+
     png_set_gAMA(png_ptr, info_ptr, file_gamma);
     png_set_gAMA_fixed(png_ptr, info_ptr, int_file_gamma);
 
@@ -4897,7 +4898,7 @@ a set of "safe" limits is applied in pngpriv.h.  These can be overridden by
 application calls to png_set_user_limits(), png_set_user_chunk_cache_max(),
 and/or png_set_user_malloc_max() that increase or decrease the limits.  Also,
 in libpng-1.5.10 the default width and height limits were increased
-from 1,000,000 to 0x7ffffff (i.e., made unlimited).  Therefore, the
+from 1,000,000 to 0x7fffffff (i.e., made unlimited).  Therefore, the
 limits are now
                                default      safe
    png_user_width_max        0x7fffffff    1,000,000
@@ -5323,7 +5324,7 @@ Since the PNG Development group is an ad-hoc body, we can't make
 an official declaration.
 
 This is your unofficial assurance that libpng from version 0.71 and
-upward through 1.6.19 are Y2K compliant.  It is my belief that earlier
+upward through 1.6.20 are Y2K compliant.  It is my belief that earlier
 versions were also Y2K compliant.
 
 Libpng only has two year fields.  One is a 2-byte unsigned integer
diff --git a/src/3rdparty/libpng/png.c b/src/3rdparty/libpng/png.c
index 6fcfad72ec1..c183e3f8faf 100644
--- a/src/3rdparty/libpng/png.c
+++ b/src/3rdparty/libpng/png.c
@@ -14,7 +14,7 @@
 #include "pngpriv.h"
 
 /* Generate a compiler error if there is an old png.h in the search path. */
-typedef png_libpng_version_1_6_19 Your_png_h_is_not_version_1_6_19;
+typedef png_libpng_version_1_6_20 Your_png_h_is_not_version_1_6_20;
 
 /* Tells libpng that we have already handled the first "num_bytes" bytes
  * of the PNG file signature.  If the PNG data is embedded into another
@@ -775,13 +775,13 @@ png_get_copyright(png_const_structrp png_ptr)
 #else
 #  ifdef __STDC__
    return PNG_STRING_NEWLINE \
-      "libpng version 1.6.19 - November 12, 2015" PNG_STRING_NEWLINE \
+      "libpng version 1.6.20 - December 3, 2015" PNG_STRING_NEWLINE \
       "Copyright (c) 1998-2015 Glenn Randers-Pehrson" PNG_STRING_NEWLINE \
       "Copyright (c) 1996-1997 Andreas Dilger" PNG_STRING_NEWLINE \
       "Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc." \
       PNG_STRING_NEWLINE;
 #  else
-   return "libpng version 1.6.19 - November 12, 2015\
+   return "libpng version 1.6.20 - December 3, 2015\
       Copyright (c) 1998-2015 Glenn Randers-Pehrson\
       Copyright (c) 1996-1997 Andreas Dilger\
       Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc.";
@@ -2343,7 +2343,7 @@ png_compare_ICC_profile_with_sRGB(png_const_structrp png_ptr,
           * Fall through to "no match".
           */
          png_chunk_report(png_ptr,
-             "Not recognizing known sRGB profile that has been edited", 
+             "Not recognizing known sRGB profile that has been edited",
              PNG_CHUNK_WARNING);
          break;
 # endif
diff --git a/src/3rdparty/libpng/png.h b/src/3rdparty/libpng/png.h
index c83051b1ca7..4d03dfc136c 100644
--- a/src/3rdparty/libpng/png.h
+++ b/src/3rdparty/libpng/png.h
@@ -1,7 +1,7 @@
 
 /* png.h - header file for PNG reference library
  *
- * libpng version 1.6.19, November 12, 2015
+ * libpng version 1.6.20, December 3, 2015
  *
  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
@@ -12,7 +12,8 @@
  * Authors and maintainers:
  *   libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat
  *   libpng versions 0.89, June 1996, through 0.96, May 1997: Andreas Dilger
- *   libpng versions 0.97, January 1998, through 1.6.19, November 12, 2015: Glenn
+ *   libpng versions 0.97, January 1998, through 1.6.20, December 3, 2015:
+ *     Glenn Randers-Pehrson.
  *   See also "Contributing Authors", below.
  */
 
@@ -24,7 +25,7 @@
  *
  * This code is released under the libpng license.
  *
- * libpng versions 1.0.7, July 1, 2000, through 1.6.19, November 12, 2015, are
+ * libpng versions 1.0.7, July 1, 2000, through 1.6.20, December 3, 2015, are
  * Copyright (c) 2000-2002, 2004, 2006-2015 Glenn Randers-Pehrson, are
  * derived from libpng-1.0.6, and are distributed according to the same
  * disclaimer and license as libpng-1.0.6 with the following individuals
@@ -185,7 +186,7 @@
  *    ...
  *    1.5.23                  15    10523  15.so.15.23[.0]
  *    ...
- *    1.6.19                  16    10619  16.so.16.19[.0]
+ *    1.6.20                  16    10620  16.so.16.20[.0]
  *
  *    Henceforth the source version will match the shared-library major
  *    and minor numbers; the shared-library major version number will be
@@ -213,13 +214,13 @@
  * Y2K compliance in libpng:
  * =========================
  *
- *    November 12, 2015
+ *    December 3, 2015
  *
  *    Since the PNG Development group is an ad-hoc body, we can't make
  *    an official declaration.
  *
  *    This is your unofficial assurance that libpng from version 0.71 and
- *    upward through 1.6.19 are Y2K compliant.  It is my belief that
+ *    upward through 1.6.20 are Y2K compliant.  It is my belief that
  *    earlier versions were also Y2K compliant.
  *
  *    Libpng only has two year fields.  One is a 2-byte unsigned integer
@@ -281,9 +282,9 @@
  */
 
 /* Version information for png.h - this should match the version in png.c */
-#define PNG_LIBPNG_VER_STRING "1.6.19"
+#define PNG_LIBPNG_VER_STRING "1.6.20"
 #define PNG_HEADER_VERSION_STRING \
-     " libpng version 1.6.19 - November 12, 2015\n"
+     " libpng version 1.6.20 - December 3, 2015\n"
 
 #define PNG_LIBPNG_VER_SONUM   16
 #define PNG_LIBPNG_VER_DLLNUM  16
@@ -291,7 +292,7 @@
 /* These should match the first 3 components of PNG_LIBPNG_VER_STRING: */
 #define PNG_LIBPNG_VER_MAJOR   1
 #define PNG_LIBPNG_VER_MINOR   6
-#define PNG_LIBPNG_VER_RELEASE 19
+#define PNG_LIBPNG_VER_RELEASE 20
 
 /* This should match the numeric part of the final component of
  * PNG_LIBPNG_VER_STRING, omitting any leading zero:
@@ -322,7 +323,7 @@
  * version 1.0.0 was mis-numbered 100 instead of 10000).  From
  * version 1.0.1 it's    xxyyzz, where x=major, y=minor, z=release
  */
-#define PNG_LIBPNG_VER 10619 /* 1.6.19 */
+#define PNG_LIBPNG_VER 10620 /* 1.6.20 */
 
 /* Library configuration: these options cannot be changed after
  * the library has been built.
@@ -432,7 +433,7 @@ extern "C" {
 /* This triggers a compiler error in png.c, if png.c and png.h
  * do not agree upon the version number.
  */
-typedef char* png_libpng_version_1_6_19;
+typedef char* png_libpng_version_1_6_20;
 
 /* Basic control structions.  Read libpng-manual.txt or libpng.3 for more info.
  *
diff --git a/src/3rdparty/libpng/pngconf.h b/src/3rdparty/libpng/pngconf.h
index f1b795b4784..92f250000ce 100644
--- a/src/3rdparty/libpng/pngconf.h
+++ b/src/3rdparty/libpng/pngconf.h
@@ -1,7 +1,7 @@
 
 /* pngconf.h - machine configurable file for libpng
  *
- * libpng version 1.6.19, July 23, 2015
+ * libpng version 1.6.20, December 3, 2015
  *
  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
diff --git a/src/3rdparty/libpng/pngerror.c b/src/3rdparty/libpng/pngerror.c
index 0781866a893..bdb959ee517 100644
--- a/src/3rdparty/libpng/pngerror.c
+++ b/src/3rdparty/libpng/pngerror.c
@@ -768,7 +768,7 @@ png_longjmp,(png_const_structrp png_ptr, int val),PNG_NORETURN)
 
    /* If control reaches this point, png_longjmp() must not return. The only
     * choice is to terminate the whole process (or maybe the thread); to do
-    * this the ANSI-C abort() function is used unless a different method is 
+    * this the ANSI-C abort() function is used unless a different method is
     * implemented by overriding the default configuration setting for
     * PNG_ABORT().
     */
diff --git a/src/3rdparty/libpng/pnginfo.h b/src/3rdparty/libpng/pnginfo.h
index c8c874dd1ea..4bd264b8690 100644
--- a/src/3rdparty/libpng/pnginfo.h
+++ b/src/3rdparty/libpng/pnginfo.h
@@ -223,7 +223,7 @@ defined(PNG_READ_BACKGROUND_SUPPORTED)
    /* Storage for unknown chunks that the library doesn't recognize. */
    png_unknown_chunkp unknown_chunks;
 
-   /* The type of this field is limited by the type of 
+   /* The type of this field is limited by the type of
     * png_struct::user_chunk_cache_max, else overflow can occur.
     */
    int                unknown_chunks_num;
diff --git a/src/3rdparty/libpng/pnglibconf.h b/src/3rdparty/libpng/pnglibconf.h
index 8b6da9eb2c7..0dba5055f7f 100644
--- a/src/3rdparty/libpng/pnglibconf.h
+++ b/src/3rdparty/libpng/pnglibconf.h
@@ -1,6 +1,6 @@
 /* pnglibconf.h - library build configuration */
 
-/* libpng version 1.6.19, July 23, 2015 */
+/* libpng version 1.6.20 - December 3, 2015 */
 
 /* Copyright (c) 1998-2014 Glenn Randers-Pehrson */
 
diff --git a/src/3rdparty/libpng/pngpread.c b/src/3rdparty/libpng/pngpread.c
index 9f68f990232..89ffc4018f6 100644
--- a/src/3rdparty/libpng/pngpread.c
+++ b/src/3rdparty/libpng/pngpread.c
@@ -133,7 +133,7 @@ png_process_some_data(png_structrp png_ptr, png_inforp info_ptr)
 void /* PRIVATE */
 png_push_read_sig(png_structrp png_ptr, png_inforp info_ptr)
 {
-   png_size_t num_checked = png_ptr->sig_bytes, /* SAFE, does not exceed 8 */ 
+   png_size_t num_checked = png_ptr->sig_bytes, /* SAFE, does not exceed 8 */
        num_to_check = 8 - num_checked;
 
    if (png_ptr->buffer_size < num_to_check)
@@ -662,7 +662,7 @@ png_process_IDAT_data(png_structrp png_ptr, png_bytep buffer,
        * change the current behavior (see comments in inflate.c
        * for why this doesn't happen at present with zlib 1.2.5).
        */
-      ret = inflate(&png_ptr->zstream, Z_SYNC_FLUSH);
+      ret = PNG_INFLATE(png_ptr, Z_SYNC_FLUSH);
 
       /* Check for any failure before proceeding. */
       if (ret != Z_OK && ret != Z_STREAM_END)
diff --git a/src/3rdparty/libpng/pngpriv.h b/src/3rdparty/libpng/pngpriv.h
index f7a45477a4c..c06deee68d7 100644
--- a/src/3rdparty/libpng/pngpriv.h
+++ b/src/3rdparty/libpng/pngpriv.h
@@ -1229,6 +1229,14 @@ PNG_INTERNAL_FUNCTION(void,png_read_finish_row,(png_structrp png_ptr),
 /* Initialize the row buffers, etc. */
 PNG_INTERNAL_FUNCTION(void,png_read_start_row,(png_structrp png_ptr),PNG_EMPTY);
 
+#if PNG_ZLIB_VERNUM >= 0x1240
+PNG_INTERNAL_FUNCTION(int,png_zlib_inflate,(png_structrp png_ptr, int flush),
+      PNG_EMPTY);
+#  define PNG_INFLATE(pp, flush) png_zlib_inflate(pp, flush)
+#else /* Zlib < 1.2.4 */
+#  define PNG_INFLATE(pp, flush) inflate(&(pp)->zstream, flush)
+#endif /* Zlib < 1.2.4 */
+
 #ifdef PNG_READ_TRANSFORMS_SUPPORTED
 /* Optional call to update the users info structure */
 PNG_INTERNAL_FUNCTION(void,png_read_transform_info,(png_structrp png_ptr,
diff --git a/src/3rdparty/libpng/pngread.c b/src/3rdparty/libpng/pngread.c
index 48aae84881d..9cb4d2e41d2 100644
--- a/src/3rdparty/libpng/pngread.c
+++ b/src/3rdparty/libpng/pngread.c
@@ -2838,7 +2838,6 @@ png_image_read_colormap(png_voidp argument)
       default:
          png_error(png_ptr, "invalid PNG color type");
          /*NOT REACHED*/
-         break;
    }
 
    /* Now deal with the output processing */
diff --git a/src/3rdparty/libpng/pngrutil.c b/src/3rdparty/libpng/pngrutil.c
index ee584a8c406..61892513521 100644
--- a/src/3rdparty/libpng/pngrutil.c
+++ b/src/3rdparty/libpng/pngrutil.c
@@ -1,7 +1,7 @@
 
 /* pngrutil.c - utilities to read a PNG file
  *
- * Last changed in libpng 1.6.19 [November 12, 2015]
+ * Last changed in libpng 1.6.20 [December 3, 2015]
  * Copyright (c) 1998-2015 Glenn Randers-Pehrson
  * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger)
  * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.)
@@ -377,10 +377,16 @@ png_inflate_claim(png_structrp png_ptr, png_uint_32 owner)
 
       if (((png_ptr->options >> PNG_MAXIMUM_INFLATE_WINDOW) & 3) ==
           PNG_OPTION_ON)
+      {
          window_bits = 15;
+         png_ptr->zstream_start = 0; /* fixed window size */
+      }
 
       else
+      {
          window_bits = 0;
+         png_ptr->zstream_start = 1;
+      }
 # else
 #   define window_bits 0
 # endif
@@ -429,6 +435,31 @@ png_inflate_claim(png_structrp png_ptr, png_uint_32 owner)
 #endif
 }
 
+#if PNG_ZLIB_VERNUM >= 0x1240
+/* Handle the start of the inflate stream if we called inflateInit2(strm,0);
+ * in this case some zlib versions skip validation of the CINFO field and, in
+ * certain circumstances, libpng may end up displaying an invalid image, in
+ * contrast to implementations that call zlib in the normal way (e.g. libpng
+ * 1.5).
+ */
+int /* PRIVATE */
+png_zlib_inflate(png_structrp png_ptr, int flush)
+{
+   if (png_ptr->zstream_start && png_ptr->zstream.avail_in > 0)
+   {
+      if ((*png_ptr->zstream.next_in >> 4) > 7)
+      {
+         png_ptr->zstream.msg = "invalid window size (libpng)";
+         return Z_DATA_ERROR;
+      }
+
+      png_ptr->zstream_start = 0;
+   }
+
+   return inflate(&png_ptr->zstream, flush);
+}
+#endif /* Zlib >= 1.2.4 */
+
 #ifdef PNG_READ_COMPRESSED_TEXT_SUPPORTED
 /* png_inflate now returns zlib error codes including Z_OK and Z_STREAM_END to
  * allow the caller to do multiple calls if required.  If the 'finish' flag is
@@ -522,7 +553,7 @@ png_inflate(png_structrp png_ptr, png_uint_32 owner, int finish,
           * the previous chunk of input data.  Tell zlib if we have reached the
           * end of the output buffer.
           */
-         ret = inflate(&png_ptr->zstream, avail_out > 0 ? Z_NO_FLUSH :
+         ret = PNG_INFLATE(png_ptr, avail_out > 0 ? Z_NO_FLUSH :
              (finish ? Z_FINISH : Z_SYNC_FLUSH));
       } while (ret == Z_OK);
 
@@ -771,7 +802,7 @@ png_inflate_read(png_structrp png_ptr, png_bytep read_buffer, uInt read_size,
           * the available output is produced; this allows reading of truncated
           * streams.
           */
-         ret = inflate(&png_ptr->zstream,
+         ret = PNG_INFLATE(png_ptr,
             *chunk_bytes > 0 ? Z_NO_FLUSH : (finish ? Z_FINISH : Z_SYNC_FLUSH));
       }
       while (ret == Z_OK && (*out_size > 0 || png_ptr->zstream.avail_out > 0));
@@ -1670,7 +1701,7 @@ png_handle_sPLT(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
    ++entry_start;
 
    /* A sample depth should follow the separator, and we should be on it  */
-   if (entry_start > buffer + length - 2)
+   if (length < 2U || entry_start > buffer + (length - 2U))
    {
       png_warning(png_ptr, "malformed sPLT chunk");
       return;
@@ -2174,7 +2205,7 @@ png_handle_pCAL(png_structrp png_ptr, png_inforp info_ptr, png_uint_32 length)
    /* We need to have at least 12 bytes after the purpose string
     * in order to get the parameter information.
     */
-   if (endptr <= buf + 12)
+   if (endptr - buf <= 12)
    {
       png_chunk_benign_error(png_ptr, "invalid");
       return;
@@ -4039,7 +4070,7 @@ png_read_IDAT_data(png_structrp png_ptr, png_bytep output,
        *
        * TODO: deal more elegantly with truncated IDAT lists.
        */
-      ret = inflate(&png_ptr->zstream, Z_NO_FLUSH);
+      ret = PNG_INFLATE(png_ptr, Z_NO_FLUSH);
 
       /* Take the unconsumed output back. */
       if (output != NULL)
diff --git a/src/3rdparty/libpng/pngset.c b/src/3rdparty/libpng/pngset.c
index 05a2134dbba..8fd7965fca5 100644
--- a/src/3rdparty/libpng/pngset.c
+++ b/src/3rdparty/libpng/pngset.c
@@ -520,8 +520,8 @@ png_set_PLTE(png_structrp png_ptr, png_inforp info_ptr,
    if (png_ptr == NULL || info_ptr == NULL)
       return;
 
-   max_palette_length = (png_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ?
-      (1 << png_ptr->bit_depth) : PNG_MAX_PALETTE_LENGTH;
+   max_palette_length = (info_ptr->color_type == PNG_COLOR_TYPE_PALETTE) ?
+      (1 << info_ptr->bit_depth) : PNG_MAX_PALETTE_LENGTH;
 
    if (num_palette < 0 || num_palette > (int) max_palette_length)
    {
@@ -1573,7 +1573,7 @@ png_set_user_limits (png_structrp png_ptr, png_uint_32 user_width_max,
 {
    /* Images with dimensions larger than these limits will be
     * rejected by png_set_IHDR().  To accept any PNG datastream
-    * regardless of dimensions, set both limits to 0x7ffffff.
+    * regardless of dimensions, set both limits to 0x7fffffff.
     */
    if (png_ptr == NULL)
       return;
diff --git a/src/3rdparty/libpng/pngstruct.h b/src/3rdparty/libpng/pngstruct.h
index c8c0e46e8b0..d0bcc7914a5 100644
--- a/src/3rdparty/libpng/pngstruct.h
+++ b/src/3rdparty/libpng/pngstruct.h
@@ -263,6 +263,9 @@ struct png_struct_def
                               /* pixel depth used for the row buffers */
    png_byte transformed_pixel_depth;
                               /* pixel depth after read/write transforms */
+#if PNG_ZLIB_VERNUM >= 0x1240
+   png_byte zstream_start;    /* at start of an input zlib stream */
+#endif /* Zlib >= 1.2.4 */
 #if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED)
    png_uint_16 filler;           /* filler bytes for pixel expansion */
 #endif
diff --git a/src/3rdparty/libpng/pngwutil.c b/src/3rdparty/libpng/pngwutil.c
index adc4729c241..0ee102b5fba 100644
--- a/src/3rdparty/libpng/pngwutil.c
+++ b/src/3rdparty/libpng/pngwutil.c
@@ -2563,7 +2563,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
    if (filter_to_do == PNG_FILTER_SUB)
    /* It's the only filter so no testing is needed */
    {
-      (void) png_setup_sub_row(png_ptr, bpp, row_bytes, mins); 
+      (void) png_setup_sub_row(png_ptr, bpp, row_bytes, mins);
       best_row = png_ptr->try_row;
    }
 
@@ -2572,7 +2572,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
       png_size_t sum;
       png_size_t lmins = mins;
 
-      sum = png_setup_sub_row(png_ptr, bpp, row_bytes, lmins); 
+      sum = png_setup_sub_row(png_ptr, bpp, row_bytes, lmins);
 
       if (sum < mins)
       {
@@ -2598,7 +2598,7 @@ png_write_find_filter(png_structrp png_ptr, png_row_infop row_info)
       png_size_t sum;
       png_size_t lmins = mins;
 
-      sum = png_setup_up_row(png_ptr, row_bytes, lmins); 
+      sum = png_setup_up_row(png_ptr, row_bytes, lmins);
 
       if (sum < mins)
       {
diff --git a/src/3rdparty/pcre/sljit/sljitNativeX86_common.c b/src/3rdparty/pcre/sljit/sljitNativeX86_common.c
index 416c15afafa..f03393a2d34 100644
--- a/src/3rdparty/pcre/sljit/sljitNativeX86_common.c
+++ b/src/3rdparty/pcre/sljit/sljitNativeX86_common.c
@@ -289,7 +289,7 @@ static void get_cpu_features(void)
 	__cpuid(CPUInfo, 1);
 	features = (sljit_ui)CPUInfo[3];
 
-#elif defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__SUNPRO_C)
+#elif defined(__GNUC__) || defined(__INTEL_COMPILER) || defined(__SUNPRO_C) || defined(__ghs)
 
 	/* AT&T syntax. */
 	__asm__ (
diff --git a/src/3rdparty/sqlite/0001-Fixing-the-SQLite3-build-for-WEC2013-again.patch b/src/3rdparty/sqlite/0001-Fixing-the-SQLite3-build-for-WEC2013-again.patch
deleted file mode 100644
index 43e61cba125..00000000000
--- a/src/3rdparty/sqlite/0001-Fixing-the-SQLite3-build-for-WEC2013-again.patch
+++ /dev/null
@@ -1,31 +0,0 @@
-From 448df48c1610745cad734df210aa2f21f26c9ae4 Mon Sep 17 00:00:00 2001
-From: Gunnar Roth <gunnar.roth@gmx.net>
-Date: Fri, 22 Jan 2016 22:38:17 +0100
-Subject: [PATCH] Fixing the SQLite3 build for WEC2013 again.
-
-The new version broke the build again
--> fix it again.
-
-Change-Id: I75761d134d97a2784f1de5076412aa814fdf9bcd
-
-diff --git a/src/3rdparty/sqlite/sqlite3.c b/src/3rdparty/sqlite/sqlite3.c
-index c0ab233..b397726 100644
---- a/src/3rdparty/sqlite/sqlite3.c
-+++ b/src/3rdparty/sqlite/sqlite3.c
-@@ -16867,6 +16867,13 @@ static void clearYMD_HMS_TZ(DateTime *p){
- #define HAVE_LOCALTIME_S 1
- #endif
- 
-+#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
-+#undef HAVE_LOCALTIME_S
-+struct tm *__cdecl localtime(const time_t *t);
-+#elif defined(_WIN32_WCE) && _WIN32_WCE >= 0x800
-+#define SQLITE_MSVC_LOCALTIME_API 1
-+#endif
-+
- #ifndef SQLITE_OMIT_LOCALTIME
- /*
- ** The following routine implements the rough equivalent of localtime_r()
--- 
-2.5.0
-
diff --git a/src/3rdparty/sqlite/shell.c b/src/3rdparty/sqlite/shell.c
deleted file mode 100644
index b7a7abcd331..00000000000
--- a/src/3rdparty/sqlite/shell.c
+++ /dev/null
@@ -1,4958 +0,0 @@
-/*
-** 2001 September 15
-**
-** The author disclaims copyright to this source code.  In place of
-** a legal notice, here is a blessing:
-**
-**    May you do good and not evil.
-**    May you find forgiveness for yourself and forgive others.
-**    May you share freely, never taking more than you give.
-**
-*************************************************************************
-** This file contains code to implement the "sqlite" command line
-** utility for accessing SQLite databases.
-*/
-#if (defined(_WIN32) || defined(WIN32)) && !defined(_CRT_SECURE_NO_WARNINGS)
-/* This needs to come before any includes for MSVC compiler */
-#define _CRT_SECURE_NO_WARNINGS
-#endif
-
-/*
-** If requested, include the SQLite compiler options file for MSVC.
-*/
-#if defined(INCLUDE_MSVC_H)
-#include "msvc.h"
-#endif
-
-/*
-** No support for loadable extensions in VxWorks.
-*/
-#if (defined(__RTP__) || defined(_WRS_KERNEL)) && !SQLITE_OMIT_LOAD_EXTENSION
-# define SQLITE_OMIT_LOAD_EXTENSION 1
-#endif
-
-/*
-** Enable large-file support for fopen() and friends on unix.
-*/
-#ifndef SQLITE_DISABLE_LFS
-# define _LARGE_FILE       1
-# ifndef _FILE_OFFSET_BITS
-#   define _FILE_OFFSET_BITS 64
-# endif
-# define _LARGEFILE_SOURCE 1
-#endif
-
-#include <stdlib.h>
-#include <string.h>
-#include <stdio.h>
-#include <assert.h>
-#include "sqlite3.h"
-#if SQLITE_USER_AUTHENTICATION
-# include "sqlite3userauth.h"
-#endif
-#include <ctype.h>
-#include <stdarg.h>
-
-#if !defined(_WIN32) && !defined(WIN32)
-# include <signal.h>
-# if !defined(__RTP__) && !defined(_WRS_KERNEL)
-#  include <pwd.h>
-# endif
-# include <unistd.h>
-# include <sys/types.h>
-#endif
-
-#if HAVE_READLINE
-# include <readline/readline.h>
-# include <readline/history.h>
-#endif
-
-#if HAVE_EDITLINE
-# include <editline/readline.h>
-#endif
-
-#if HAVE_EDITLINE || HAVE_READLINE
-
-# define shell_add_history(X) add_history(X)
-# define shell_read_history(X) read_history(X)
-# define shell_write_history(X) write_history(X)
-# define shell_stifle_history(X) stifle_history(X)
-# define shell_readline(X) readline(X)
-
-#elif HAVE_LINENOISE
-
-# include "linenoise.h"
-# define shell_add_history(X) linenoiseHistoryAdd(X)
-# define shell_read_history(X) linenoiseHistoryLoad(X)
-# define shell_write_history(X) linenoiseHistorySave(X)
-# define shell_stifle_history(X) linenoiseHistorySetMaxLen(X)
-# define shell_readline(X) linenoise(X)
-
-#else
-
-# define shell_read_history(X) 
-# define shell_write_history(X)
-# define shell_stifle_history(X)
-
-# define SHELL_USE_LOCAL_GETLINE 1
-#endif
-
-
-#if defined(_WIN32) || defined(WIN32)
-# include <io.h>
-# include <fcntl.h>
-# define isatty(h) _isatty(h)
-# ifndef access
-#  define access(f,m) _access((f),(m))
-# endif
-# undef popen
-# define popen _popen
-# undef pclose
-# define pclose _pclose
-#else
- /* Make sure isatty() has a prototype. */
- extern int isatty(int);
-
-# if !defined(__RTP__) && !defined(_WRS_KERNEL)
-  /* popen and pclose are not C89 functions and so are
-  ** sometimes omitted from the <stdio.h> header */
-   extern FILE *popen(const char*,const char*);
-   extern int pclose(FILE*);
-# else
-#  define SQLITE_OMIT_POPEN 1
-# endif
-#endif
-
-#if defined(_WIN32_WCE)
-/* Windows CE (arm-wince-mingw32ce-gcc) does not provide isatty()
- * thus we always assume that we have a console. That can be
- * overridden with the -batch command line option.
- */
-#define isatty(x) 1
-#endif
-
-/* ctype macros that work with signed characters */
-#define IsSpace(X)  isspace((unsigned char)X)
-#define IsDigit(X)  isdigit((unsigned char)X)
-#define ToLower(X)  (char)tolower((unsigned char)X)
-
-/* On Windows, we normally run with output mode of TEXT so that \n characters
-** are automatically translated into \r\n.  However, this behavior needs
-** to be disabled in some cases (ex: when generating CSV output and when
-** rendering quoted strings that contain \n characters).  The following
-** routines take care of that.
-*/
-#if defined(_WIN32) || defined(WIN32)
-static void setBinaryMode(FILE *out){
-  fflush(out);
-  _setmode(_fileno(out), _O_BINARY);
-}
-static void setTextMode(FILE *out){
-  fflush(out);
-  _setmode(_fileno(out), _O_TEXT);
-}
-#else
-# define setBinaryMode(X)
-# define setTextMode(X)
-#endif
-
-
-/* True if the timer is enabled */
-static int enableTimer = 0;
-
-/* Return the current wall-clock time */
-static sqlite3_int64 timeOfDay(void){
-  static sqlite3_vfs *clockVfs = 0;
-  sqlite3_int64 t;
-  if( clockVfs==0 ) clockVfs = sqlite3_vfs_find(0);
-  if( clockVfs->iVersion>=2 && clockVfs->xCurrentTimeInt64!=0 ){
-    clockVfs->xCurrentTimeInt64(clockVfs, &t);
-  }else{
-    double r;
-    clockVfs->xCurrentTime(clockVfs, &r);
-    t = (sqlite3_int64)(r*86400000.0);
-  }
-  return t;
-}
-
-#if !defined(_WIN32) && !defined(WIN32) && !defined(__minux)
-#include <sys/time.h>
-#include <sys/resource.h>
-
-/* VxWorks does not support getrusage() as far as we can determine */
-#if defined(_WRS_KERNEL) || defined(__RTP__)
-struct rusage {
-  struct timeval ru_utime; /* user CPU time used */
-  struct timeval ru_stime; /* system CPU time used */
-};
-#define getrusage(A,B) memset(B,0,sizeof(*B))
-#endif
-
-/* Saved resource information for the beginning of an operation */
-static struct rusage sBegin;  /* CPU time at start */
-static sqlite3_int64 iBegin;  /* Wall-clock time at start */
-
-/*
-** Begin timing an operation
-*/
-static void beginTimer(void){
-  if( enableTimer ){
-    getrusage(RUSAGE_SELF, &sBegin);
-    iBegin = timeOfDay();
-  }
-}
-
-/* Return the difference of two time_structs in seconds */
-static double timeDiff(struct timeval *pStart, struct timeval *pEnd){
-  return (pEnd->tv_usec - pStart->tv_usec)*0.000001 + 
-         (double)(pEnd->tv_sec - pStart->tv_sec);
-}
-
-/*
-** Print the timing results.
-*/
-static void endTimer(void){
-  if( enableTimer ){
-    sqlite3_int64 iEnd = timeOfDay();
-    struct rusage sEnd;
-    getrusage(RUSAGE_SELF, &sEnd);
-    printf("Run Time: real %.3f user %f sys %f\n",
-       (iEnd - iBegin)*0.001,
-       timeDiff(&sBegin.ru_utime, &sEnd.ru_utime),
-       timeDiff(&sBegin.ru_stime, &sEnd.ru_stime));
-  }
-}
-
-#define BEGIN_TIMER beginTimer()
-#define END_TIMER endTimer()
-#define HAS_TIMER 1
-
-#elif (defined(_WIN32) || defined(WIN32))
-
-#include <windows.h>
-
-/* Saved resource information for the beginning of an operation */
-static HANDLE hProcess;
-static FILETIME ftKernelBegin;
-static FILETIME ftUserBegin;
-static sqlite3_int64 ftWallBegin;
-typedef BOOL (WINAPI *GETPROCTIMES)(HANDLE, LPFILETIME, LPFILETIME,
-                                    LPFILETIME, LPFILETIME);
-static GETPROCTIMES getProcessTimesAddr = NULL;
-
-/*
-** Check to see if we have timer support.  Return 1 if necessary
-** support found (or found previously).
-*/
-static int hasTimer(void){
-  if( getProcessTimesAddr ){
-    return 1;
-  } else {
-    /* GetProcessTimes() isn't supported in WIN95 and some other Windows
-    ** versions. See if the version we are running on has it, and if it
-    ** does, save off a pointer to it and the current process handle.
-    */
-    hProcess = GetCurrentProcess();
-    if( hProcess ){
-      HINSTANCE hinstLib = LoadLibrary(TEXT("Kernel32.dll"));
-      if( NULL != hinstLib ){
-        getProcessTimesAddr =
-            (GETPROCTIMES) GetProcAddress(hinstLib, "GetProcessTimes");
-        if( NULL != getProcessTimesAddr ){
-          return 1;
-        }
-        FreeLibrary(hinstLib); 
-      }
-    }
-  }
-  return 0;
-}
-
-/*
-** Begin timing an operation
-*/
-static void beginTimer(void){
-  if( enableTimer && getProcessTimesAddr ){
-    FILETIME ftCreation, ftExit;
-    getProcessTimesAddr(hProcess,&ftCreation,&ftExit,
-                        &ftKernelBegin,&ftUserBegin);
-    ftWallBegin = timeOfDay();
-  }
-}
-
-/* Return the difference of two FILETIME structs in seconds */
-static double timeDiff(FILETIME *pStart, FILETIME *pEnd){
-  sqlite_int64 i64Start = *((sqlite_int64 *) pStart);
-  sqlite_int64 i64End = *((sqlite_int64 *) pEnd);
-  return (double) ((i64End - i64Start) / 10000000.0);
-}
-
-/*
-** Print the timing results.
-*/
-static void endTimer(void){
-  if( enableTimer && getProcessTimesAddr){
-    FILETIME ftCreation, ftExit, ftKernelEnd, ftUserEnd;
-    sqlite3_int64 ftWallEnd = timeOfDay();
-    getProcessTimesAddr(hProcess,&ftCreation,&ftExit,&ftKernelEnd,&ftUserEnd);
-    printf("Run Time: real %.3f user %f sys %f\n",
-       (ftWallEnd - ftWallBegin)*0.001,
-       timeDiff(&ftUserBegin, &ftUserEnd),
-       timeDiff(&ftKernelBegin, &ftKernelEnd));
-  }
-}
-
-#define BEGIN_TIMER beginTimer()
-#define END_TIMER endTimer()
-#define HAS_TIMER hasTimer()
-
-#else
-#define BEGIN_TIMER 
-#define END_TIMER
-#define HAS_TIMER 0
-#endif
-
-/*
-** Used to prevent warnings about unused parameters
-*/
-#define UNUSED_PARAMETER(x) (void)(x)
-
-/*
-** If the following flag is set, then command execution stops
-** at an error if we are not interactive.
-*/
-static int bail_on_error = 0;
-
-/*
-** Threat stdin as an interactive input if the following variable
-** is true.  Otherwise, assume stdin is connected to a file or pipe.
-*/
-static int stdin_is_interactive = 1;
-
-/*
-** On Windows systems we have to know if standard output is a console
-** in order to translate UTF-8 into MBCS.  The following variable is
-** true if translation is required.
-*/
-static int stdout_is_console = 1;
-
-/*
-** The following is the open SQLite database.  We make a pointer
-** to this database a static variable so that it can be accessed
-** by the SIGINT handler to interrupt database processing.
-*/
-static sqlite3 *globalDb = 0;
-
-/*
-** True if an interrupt (Control-C) has been received.
-*/
-static volatile int seenInterrupt = 0;
-
-/*
-** This is the name of our program. It is set in main(), used
-** in a number of other places, mostly for error messages.
-*/
-static char *Argv0;
-
-/*
-** Prompt strings. Initialized in main. Settable with
-**   .prompt main continue
-*/
-static char mainPrompt[20];     /* First line prompt. default: "sqlite> "*/
-static char continuePrompt[20]; /* Continuation prompt. default: "   ...> " */
-
-/*
-** Write I/O traces to the following stream.
-*/
-#ifdef SQLITE_ENABLE_IOTRACE
-static FILE *iotrace = 0;
-#endif
-
-/*
-** This routine works like printf in that its first argument is a
-** format string and subsequent arguments are values to be substituted
-** in place of % fields.  The result of formatting this string
-** is written to iotrace.
-*/
-#ifdef SQLITE_ENABLE_IOTRACE
-static void SQLITE_CDECL iotracePrintf(const char *zFormat, ...){
-  va_list ap;
-  char *z;
-  if( iotrace==0 ) return;
-  va_start(ap, zFormat);
-  z = sqlite3_vmprintf(zFormat, ap);
-  va_end(ap);
-  fprintf(iotrace, "%s", z);
-  sqlite3_free(z);
-}
-#endif
-
-
-/*
-** Determines if a string is a number of not.
-*/
-static int isNumber(const char *z, int *realnum){
-  if( *z=='-' || *z=='+' ) z++;
-  if( !IsDigit(*z) ){
-    return 0;
-  }
-  z++;
-  if( realnum ) *realnum = 0;
-  while( IsDigit(*z) ){ z++; }
-  if( *z=='.' ){
-    z++;
-    if( !IsDigit(*z) ) return 0;
-    while( IsDigit(*z) ){ z++; }
-    if( realnum ) *realnum = 1;
-  }
-  if( *z=='e' || *z=='E' ){
-    z++;
-    if( *z=='+' || *z=='-' ) z++;
-    if( !IsDigit(*z) ) return 0;
-    while( IsDigit(*z) ){ z++; }
-    if( realnum ) *realnum = 1;
-  }
-  return *z==0;
-}
-
-/*
-** A global char* and an SQL function to access its current value 
-** from within an SQL statement. This program used to use the 
-** sqlite_exec_printf() API to substitue a string into an SQL statement.
-** The correct way to do this with sqlite3 is to use the bind API, but
-** since the shell is built around the callback paradigm it would be a lot
-** of work. Instead just use this hack, which is quite harmless.
-*/
-static const char *zShellStatic = 0;
-static void shellstaticFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  assert( 0==argc );
-  assert( zShellStatic );
-  UNUSED_PARAMETER(argc);
-  UNUSED_PARAMETER(argv);
-  sqlite3_result_text(context, zShellStatic, -1, SQLITE_STATIC);
-}
-
-
-/*
-** Compute a string length that is limited to what can be stored in
-** lower 30 bits of a 32-bit signed integer.
-*/
-static int strlen30(const char *z){
-  const char *z2 = z;
-  while( *z2 ){ z2++; }
-  return 0x3fffffff & (int)(z2 - z);
-}
-
-/*
-** This routine reads a line of text from FILE in, stores
-** the text in memory obtained from malloc() and returns a pointer
-** to the text.  NULL is returned at end of file, or if malloc()
-** fails.
-**
-** If zLine is not NULL then it is a malloced buffer returned from
-** a previous call to this routine that may be reused.
-*/
-static char *local_getline(char *zLine, FILE *in){
-  int nLine = zLine==0 ? 0 : 100;
-  int n = 0;
-
-  while( 1 ){
-    if( n+100>nLine ){
-      nLine = nLine*2 + 100;
-      zLine = realloc(zLine, nLine);
-      if( zLine==0 ) return 0;
-    }
-    if( fgets(&zLine[n], nLine - n, in)==0 ){
-      if( n==0 ){
-        free(zLine);
-        return 0;
-      }
-      zLine[n] = 0;
-      break;
-    }
-    while( zLine[n] ) n++;
-    if( n>0 && zLine[n-1]=='\n' ){
-      n--;
-      if( n>0 && zLine[n-1]=='\r' ) n--;
-      zLine[n] = 0;
-      break;
-    }
-  }
-#if defined(_WIN32) || defined(WIN32)
-  /* For interactive input on Windows systems, translate the 
-  ** multi-byte characterset characters into UTF-8. */
-  if( stdin_is_interactive ){
-    extern char *sqlite3_win32_mbcs_to_utf8(const char*);
-    char *zTrans = sqlite3_win32_mbcs_to_utf8(zLine);
-    if( zTrans ){
-      int nTrans = strlen30(zTrans)+1;
-      if( nTrans>nLine ){
-        zLine = realloc(zLine, nTrans);
-        if( zLine==0 ){
-          sqlite3_free(zTrans);
-          return 0;
-        }
-      }
-      memcpy(zLine, zTrans, nTrans);
-      sqlite3_free(zTrans);
-    }
-  }
-#endif /* defined(_WIN32) || defined(WIN32) */
-  return zLine;
-}
-
-/*
-** Retrieve a single line of input text.
-**
-** If in==0 then read from standard input and prompt before each line.
-** If isContinuation is true, then a continuation prompt is appropriate.
-** If isContinuation is zero, then the main prompt should be used.
-**
-** If zPrior is not NULL then it is a buffer from a prior call to this
-** routine that can be reused.
-**
-** The result is stored in space obtained from malloc() and must either
-** be freed by the caller or else passed back into this routine via the
-** zPrior argument for reuse.
-*/
-static char *one_input_line(FILE *in, char *zPrior, int isContinuation){
-  char *zPrompt;
-  char *zResult;
-  if( in!=0 ){
-    zResult = local_getline(zPrior, in);
-  }else{
-    zPrompt = isContinuation ? continuePrompt : mainPrompt;
-#if SHELL_USE_LOCAL_GETLINE
-    printf("%s", zPrompt);
-    fflush(stdout);
-    zResult = local_getline(zPrior, stdin);
-#else
-    free(zPrior);
-    zResult = shell_readline(zPrompt);
-    if( zResult && *zResult ) shell_add_history(zResult);
-#endif
-  }
-  return zResult;
-}
-
-/*
-** Render output like fprintf().  Except, if the output is going to the
-** console and if this is running on a Windows machine, translate the
-** output from UTF-8 into MBCS.
-*/
-#if defined(_WIN32) || defined(WIN32)
-void utf8_printf(FILE *out, const char *zFormat, ...){
-  va_list ap;
-  va_start(ap, zFormat);
-  if( stdout_is_console && (out==stdout || out==stderr) ){
-    extern char *sqlite3_win32_utf8_to_mbcs(const char*);
-    char *z1 = sqlite3_vmprintf(zFormat, ap);
-    char *z2 = sqlite3_win32_utf8_to_mbcs(z1);
-    sqlite3_free(z1);
-    fputs(z2, out);
-    sqlite3_free(z2);
-  }else{
-    vfprintf(out, zFormat, ap);
-  }
-  va_end(ap);
-}
-#elif !defined(utf8_printf)
-# define utf8_printf fprintf
-#endif
-
-/*
-** Render output like fprintf().  This should not be used on anything that
-** includes string formatting (e.g. "%s").
-*/
-#if !defined(raw_printf)
-# define raw_printf fprintf
-#endif
-
-/*
-** Shell output mode information from before ".explain on", 
-** saved so that it can be restored by ".explain off"
-*/
-typedef struct SavedModeInfo SavedModeInfo;
-struct SavedModeInfo {
-  int valid;          /* Is there legit data in here? */
-  int mode;           /* Mode prior to ".explain on" */
-  int showHeader;     /* The ".header" setting prior to ".explain on" */
-  int colWidth[100];  /* Column widths prior to ".explain on" */
-};
-
-/*
-** State information about the database connection is contained in an
-** instance of the following structure.
-*/
-typedef struct ShellState ShellState;
-struct ShellState {
-  sqlite3 *db;           /* The database */
-  int echoOn;            /* True to echo input commands */
-  int autoEQP;           /* Run EXPLAIN QUERY PLAN prior to seach SQL stmt */
-  int statsOn;           /* True to display memory stats before each finalize */
-  int scanstatsOn;       /* True to display scan stats before each finalize */
-  int countChanges;      /* True to display change counts */
-  int backslashOn;       /* Resolve C-style \x escapes in SQL input text */
-  int outCount;          /* Revert to stdout when reaching zero */
-  int cnt;               /* Number of records displayed so far */
-  FILE *out;             /* Write results here */
-  FILE *traceOut;        /* Output for sqlite3_trace() */
-  int nErr;              /* Number of errors seen */
-  int mode;              /* An output mode setting */
-  int writableSchema;    /* True if PRAGMA writable_schema=ON */
-  int showHeader;        /* True to show column names in List or Column mode */
-  unsigned shellFlgs;    /* Various flags */
-  char *zDestTable;      /* Name of destination table when MODE_Insert */
-  char colSeparator[20]; /* Column separator character for several modes */
-  char rowSeparator[20]; /* Row separator character for MODE_Ascii */
-  int colWidth[100];     /* Requested width of each column when in column mode*/
-  int actualWidth[100];  /* Actual width of each column */
-  char nullValue[20];    /* The text to print when a NULL comes back from
-                         ** the database */
-  SavedModeInfo normalMode;/* Holds the mode just before .explain ON */
-  char outfile[FILENAME_MAX]; /* Filename for *out */
-  const char *zDbFilename;    /* name of the database file */
-  char *zFreeOnClose;         /* Filename to free when closing */
-  const char *zVfs;           /* Name of VFS to use */
-  sqlite3_stmt *pStmt;   /* Current statement if any. */
-  FILE *pLog;            /* Write log output here */
-  int *aiIndent;         /* Array of indents used in MODE_Explain */
-  int nIndent;           /* Size of array aiIndent[] */
-  int iIndent;           /* Index of current op in aiIndent[] */
-};
-
-/*
-** These are the allowed shellFlgs values
-*/
-#define SHFLG_Scratch     0x00001     /* The --scratch option is used */
-#define SHFLG_Pagecache   0x00002     /* The --pagecache option is used */
-#define SHFLG_Lookaside   0x00004     /* Lookaside memory is used */
-
-/*
-** These are the allowed modes.
-*/
-#define MODE_Line     0  /* One column per line.  Blank line between records */
-#define MODE_Column   1  /* One record per line in neat columns */
-#define MODE_List     2  /* One record per line with a separator */
-#define MODE_Semi     3  /* Same as MODE_List but append ";" to each line */
-#define MODE_Html     4  /* Generate an XHTML table */
-#define MODE_Insert   5  /* Generate SQL "insert" statements */
-#define MODE_Tcl      6  /* Generate ANSI-C or TCL quoted elements */
-#define MODE_Csv      7  /* Quote strings, numbers are plain */
-#define MODE_Explain  8  /* Like MODE_Column, but do not truncate data */
-#define MODE_Ascii    9  /* Use ASCII unit and record separators (0x1F/0x1E) */
-
-static const char *modeDescr[] = {
-  "line",
-  "column",
-  "list",
-  "semi",
-  "html",
-  "insert",
-  "tcl",
-  "csv",
-  "explain",
-  "ascii",
-};
-
-/*
-** These are the column/row/line separators used by the various
-** import/export modes.
-*/
-#define SEP_Column    "|"
-#define SEP_Row       "\n"
-#define SEP_Tab       "\t"
-#define SEP_Space     " "
-#define SEP_Comma     ","
-#define SEP_CrLf      "\r\n"
-#define SEP_Unit      "\x1F"
-#define SEP_Record    "\x1E"
-
-/*
-** Number of elements in an array
-*/
-#define ArraySize(X)  (int)(sizeof(X)/sizeof(X[0]))
-
-/*
-** A callback for the sqlite3_log() interface.
-*/
-static void shellLog(void *pArg, int iErrCode, const char *zMsg){
-  ShellState *p = (ShellState*)pArg;
-  if( p->pLog==0 ) return;
-  utf8_printf(p->pLog, "(%d) %s\n", iErrCode, zMsg);
-  fflush(p->pLog);
-}
-
-/*
-** Output the given string as a hex-encoded blob (eg. X'1234' )
-*/
-static void output_hex_blob(FILE *out, const void *pBlob, int nBlob){
-  int i;
-  char *zBlob = (char *)pBlob;
-  raw_printf(out,"X'");
-  for(i=0; i<nBlob; i++){ raw_printf(out,"%02x",zBlob[i]&0xff); }
-  raw_printf(out,"'");
-}
-
-/*
-** Output the given string as a quoted string using SQL quoting conventions.
-*/
-static void output_quoted_string(FILE *out, const char *z){
-  int i;
-  int nSingle = 0;
-  setBinaryMode(out);
-  for(i=0; z[i]; i++){
-    if( z[i]=='\'' ) nSingle++;
-  }
-  if( nSingle==0 ){
-    utf8_printf(out,"'%s'",z);
-  }else{
-    raw_printf(out,"'");
-    while( *z ){
-      for(i=0; z[i] && z[i]!='\''; i++){}
-      if( i==0 ){
-        raw_printf(out,"''");
-        z++;
-      }else if( z[i]=='\'' ){
-        utf8_printf(out,"%.*s''",i,z);
-        z += i+1;
-      }else{
-        utf8_printf(out,"%s",z);
-        break;
-      }
-    }
-    raw_printf(out,"'");
-  }
-  setTextMode(out);
-}
-
-/*
-** Output the given string as a quoted according to C or TCL quoting rules.
-*/
-static void output_c_string(FILE *out, const char *z){
-  unsigned int c;
-  fputc('"', out);
-  while( (c = *(z++))!=0 ){
-    if( c=='\\' ){
-      fputc(c, out);
-      fputc(c, out);
-    }else if( c=='"' ){
-      fputc('\\', out);
-      fputc('"', out);
-    }else if( c=='\t' ){
-      fputc('\\', out);
-      fputc('t', out);
-    }else if( c=='\n' ){
-      fputc('\\', out);
-      fputc('n', out);
-    }else if( c=='\r' ){
-      fputc('\\', out);
-      fputc('r', out);
-    }else if( !isprint(c&0xff) ){
-      raw_printf(out, "\\%03o", c&0xff);
-    }else{
-      fputc(c, out);
-    }
-  }
-  fputc('"', out);
-}
-
-/*
-** Output the given string with characters that are special to
-** HTML escaped.
-*/
-static void output_html_string(FILE *out, const char *z){
-  int i;
-  if( z==0 ) z = "";
-  while( *z ){
-    for(i=0;   z[i] 
-            && z[i]!='<' 
-            && z[i]!='&' 
-            && z[i]!='>' 
-            && z[i]!='\"' 
-            && z[i]!='\'';
-        i++){}
-    if( i>0 ){
-      utf8_printf(out,"%.*s",i,z);
-    }
-    if( z[i]=='<' ){
-      raw_printf(out,"&lt;");
-    }else if( z[i]=='&' ){
-      raw_printf(out,"&amp;");
-    }else if( z[i]=='>' ){
-      raw_printf(out,"&gt;");
-    }else if( z[i]=='\"' ){
-      raw_printf(out,"&quot;");
-    }else if( z[i]=='\'' ){
-      raw_printf(out,"&#39;");
-    }else{
-      break;
-    }
-    z += i + 1;
-  }
-}
-
-/*
-** If a field contains any character identified by a 1 in the following
-** array, then the string must be quoted for CSV.
-*/
-static const char needCsvQuote[] = {
-  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
-  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
-  1, 0, 1, 0, 0, 0, 0, 1,   0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 0, 
-  0, 0, 0, 0, 0, 0, 0, 0,   0, 0, 0, 0, 0, 0, 0, 1, 
-  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
-  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
-  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
-  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
-  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
-  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
-  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
-  1, 1, 1, 1, 1, 1, 1, 1,   1, 1, 1, 1, 1, 1, 1, 1,   
-};
-
-/*
-** Output a single term of CSV.  Actually, p->colSeparator is used for
-** the separator, which may or may not be a comma.  p->nullValue is
-** the null value.  Strings are quoted if necessary.  The separator
-** is only issued if bSep is true.
-*/
-static void output_csv(ShellState *p, const char *z, int bSep){
-  FILE *out = p->out;
-  if( z==0 ){
-    utf8_printf(out,"%s",p->nullValue);
-  }else{
-    int i;
-    int nSep = strlen30(p->colSeparator);
-    for(i=0; z[i]; i++){
-      if( needCsvQuote[((unsigned char*)z)[i]] 
-         || (z[i]==p->colSeparator[0] && 
-             (nSep==1 || memcmp(z, p->colSeparator, nSep)==0)) ){
-        i = 0;
-        break;
-      }
-    }
-    if( i==0 ){
-      putc('"', out);
-      for(i=0; z[i]; i++){
-        if( z[i]=='"' ) putc('"', out);
-        putc(z[i], out);
-      }
-      putc('"', out);
-    }else{
-      utf8_printf(out, "%s", z);
-    }
-  }
-  if( bSep ){
-    utf8_printf(p->out, "%s", p->colSeparator);
-  }
-}
-
-#ifdef SIGINT
-/*
-** This routine runs when the user presses Ctrl-C
-*/
-static void interrupt_handler(int NotUsed){
-  UNUSED_PARAMETER(NotUsed);
-  seenInterrupt++;
-  if( seenInterrupt>2 ) exit(1);
-  if( globalDb ) sqlite3_interrupt(globalDb);
-}
-#endif
-
-/*
-** This is the callback routine that the shell
-** invokes for each row of a query result.
-*/
-static int shell_callback(
-  void *pArg,
-  int nArg,        /* Number of result columns */
-  char **azArg,    /* Text of each result column */
-  char **azCol,    /* Column names */
-  int *aiType      /* Column types */
-){
-  int i;
-  ShellState *p = (ShellState*)pArg;
-
-  switch( p->mode ){
-    case MODE_Line: {
-      int w = 5;
-      if( azArg==0 ) break;
-      for(i=0; i<nArg; i++){
-        int len = strlen30(azCol[i] ? azCol[i] : "");
-        if( len>w ) w = len;
-      }
-      if( p->cnt++>0 ) utf8_printf(p->out, "%s", p->rowSeparator);
-      for(i=0; i<nArg; i++){
-        utf8_printf(p->out,"%*s = %s%s", w, azCol[i],
-                azArg[i] ? azArg[i] : p->nullValue, p->rowSeparator);
-      }
-      break;
-    }
-    case MODE_Explain:
-    case MODE_Column: {
-      if( p->cnt++==0 ){
-        for(i=0; i<nArg; i++){
-          int w, n;
-          if( i<ArraySize(p->colWidth) ){
-            w = p->colWidth[i];
-          }else{
-            w = 0;
-          }
-          if( w==0 ){
-            w = strlen30(azCol[i] ? azCol[i] : "");
-            if( w<10 ) w = 10;
-            n = strlen30(azArg && azArg[i] ? azArg[i] : p->nullValue);
-            if( w<n ) w = n;
-          }
-          if( i<ArraySize(p->actualWidth) ){
-            p->actualWidth[i] = w;
-          }
-          if( p->showHeader ){
-            if( w<0 ){
-              utf8_printf(p->out,"%*.*s%s",-w,-w,azCol[i],
-                      i==nArg-1 ? p->rowSeparator : "  ");
-            }else{
-              utf8_printf(p->out,"%-*.*s%s",w,w,azCol[i],
-                      i==nArg-1 ? p->rowSeparator : "  ");
-            }
-          }
-        }
-        if( p->showHeader ){
-          for(i=0; i<nArg; i++){
-            int w;
-            if( i<ArraySize(p->actualWidth) ){
-               w = p->actualWidth[i];
-               if( w<0 ) w = -w;
-            }else{
-               w = 10;
-            }
-            utf8_printf(p->out,"%-*.*s%s",w,w,
-                   "----------------------------------------------------------"
-                   "----------------------------------------------------------",
-                    i==nArg-1 ? p->rowSeparator : "  ");
-          }
-        }
-      }
-      if( azArg==0 ) break;
-      for(i=0; i<nArg; i++){
-        int w;
-        if( i<ArraySize(p->actualWidth) ){
-           w = p->actualWidth[i];
-        }else{
-           w = 10;
-        }
-        if( p->mode==MODE_Explain && azArg[i] && strlen30(azArg[i])>w ){
-          w = strlen30(azArg[i]);
-        }
-        if( i==1 && p->aiIndent && p->pStmt ){
-          if( p->iIndent<p->nIndent ){
-            utf8_printf(p->out, "%*.s", p->aiIndent[p->iIndent], "");
-          }
-          p->iIndent++;
-        }
-        if( w<0 ){
-          utf8_printf(p->out,"%*.*s%s",-w,-w,
-              azArg[i] ? azArg[i] : p->nullValue,
-              i==nArg-1 ? p->rowSeparator : "  ");
-        }else{
-          utf8_printf(p->out,"%-*.*s%s",w,w,
-              azArg[i] ? azArg[i] : p->nullValue,
-              i==nArg-1 ? p->rowSeparator : "  ");
-        }
-      }
-      break;
-    }
-    case MODE_Semi:
-    case MODE_List: {
-      if( p->cnt++==0 && p->showHeader ){
-        for(i=0; i<nArg; i++){
-          utf8_printf(p->out,"%s%s",azCol[i],
-                  i==nArg-1 ? p->rowSeparator : p->colSeparator);
-        }
-      }
-      if( azArg==0 ) break;
-      for(i=0; i<nArg; i++){
-        char *z = azArg[i];
-        if( z==0 ) z = p->nullValue;
-        utf8_printf(p->out, "%s", z);
-        if( i<nArg-1 ){
-          utf8_printf(p->out, "%s", p->colSeparator);
-        }else if( p->mode==MODE_Semi ){
-          utf8_printf(p->out, ";%s", p->rowSeparator);
-        }else{
-          utf8_printf(p->out, "%s", p->rowSeparator);
-        }
-      }
-      break;
-    }
-    case MODE_Html: {
-      if( p->cnt++==0 && p->showHeader ){
-        raw_printf(p->out,"<TR>");
-        for(i=0; i<nArg; i++){
-          raw_printf(p->out,"<TH>");
-          output_html_string(p->out, azCol[i]);
-          raw_printf(p->out,"</TH>\n");
-        }
-        raw_printf(p->out,"</TR>\n");
-      }
-      if( azArg==0 ) break;
-      raw_printf(p->out,"<TR>");
-      for(i=0; i<nArg; i++){
-        raw_printf(p->out,"<TD>");
-        output_html_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
-        raw_printf(p->out,"</TD>\n");
-      }
-      raw_printf(p->out,"</TR>\n");
-      break;
-    }
-    case MODE_Tcl: {
-      if( p->cnt++==0 && p->showHeader ){
-        for(i=0; i<nArg; i++){
-          output_c_string(p->out,azCol[i] ? azCol[i] : "");
-          if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator);
-        }
-        utf8_printf(p->out, "%s", p->rowSeparator);
-      }
-      if( azArg==0 ) break;
-      for(i=0; i<nArg; i++){
-        output_c_string(p->out, azArg[i] ? azArg[i] : p->nullValue);
-        if(i<nArg-1) utf8_printf(p->out, "%s", p->colSeparator);
-      }
-      utf8_printf(p->out, "%s", p->rowSeparator);
-      break;
-    }
-    case MODE_Csv: {
-      setBinaryMode(p->out);
-      if( p->cnt++==0 && p->showHeader ){
-        for(i=0; i<nArg; i++){
-          output_csv(p, azCol[i] ? azCol[i] : "", i<nArg-1);
-        }
-        utf8_printf(p->out, "%s", p->rowSeparator);
-      }
-      if( nArg>0 ){
-        for(i=0; i<nArg; i++){
-          output_csv(p, azArg[i], i<nArg-1);
-        }
-        utf8_printf(p->out, "%s", p->rowSeparator);
-      }
-      setTextMode(p->out);
-      break;
-    }
-    case MODE_Insert: {
-      p->cnt++;
-      if( azArg==0 ) break;
-      utf8_printf(p->out,"INSERT INTO %s",p->zDestTable);
-      if( p->showHeader ){
-        raw_printf(p->out,"(");
-        for(i=0; i<nArg; i++){
-          char *zSep = i>0 ? ",": "";
-          utf8_printf(p->out, "%s%s", zSep, azCol[i]);
-        }
-        raw_printf(p->out,")");
-      }
-      raw_printf(p->out," VALUES(");
-      for(i=0; i<nArg; i++){
-        char *zSep = i>0 ? ",": "";
-        if( (azArg[i]==0) || (aiType && aiType[i]==SQLITE_NULL) ){
-          utf8_printf(p->out,"%sNULL",zSep);
-        }else if( aiType && aiType[i]==SQLITE_TEXT ){
-          if( zSep[0] ) utf8_printf(p->out,"%s",zSep);
-          output_quoted_string(p->out, azArg[i]);
-        }else if( aiType && (aiType[i]==SQLITE_INTEGER
-                             || aiType[i]==SQLITE_FLOAT) ){
-          utf8_printf(p->out,"%s%s",zSep, azArg[i]);
-        }else if( aiType && aiType[i]==SQLITE_BLOB && p->pStmt ){
-          const void *pBlob = sqlite3_column_blob(p->pStmt, i);
-          int nBlob = sqlite3_column_bytes(p->pStmt, i);
-          if( zSep[0] ) utf8_printf(p->out,"%s",zSep);
-          output_hex_blob(p->out, pBlob, nBlob);
-        }else if( isNumber(azArg[i], 0) ){
-          utf8_printf(p->out,"%s%s",zSep, azArg[i]);
-        }else{
-          if( zSep[0] ) utf8_printf(p->out,"%s",zSep);
-          output_quoted_string(p->out, azArg[i]);
-        }
-      }
-      raw_printf(p->out,");\n");
-      break;
-    }
-    case MODE_Ascii: {
-      if( p->cnt++==0 && p->showHeader ){
-        for(i=0; i<nArg; i++){
-          if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator);
-          utf8_printf(p->out,"%s",azCol[i] ? azCol[i] : "");
-        }
-        utf8_printf(p->out, "%s", p->rowSeparator);
-      }
-      if( azArg==0 ) break;
-      for(i=0; i<nArg; i++){
-        if( i>0 ) utf8_printf(p->out, "%s", p->colSeparator);
-        utf8_printf(p->out,"%s",azArg[i] ? azArg[i] : p->nullValue);
-      }
-      utf8_printf(p->out, "%s", p->rowSeparator);
-      break;
-    }
-  }
-  return 0;
-}
-
-/*
-** This is the callback routine that the SQLite library
-** invokes for each row of a query result.
-*/
-static int callback(void *pArg, int nArg, char **azArg, char **azCol){
-  /* since we don't have type info, call the shell_callback with a NULL value */
-  return shell_callback(pArg, nArg, azArg, azCol, NULL);
-}
-
-/*
-** Set the destination table field of the ShellState structure to
-** the name of the table given.  Escape any quote characters in the
-** table name.
-*/
-static void set_table_name(ShellState *p, const char *zName){
-  int i, n;
-  int needQuote;
-  char *z;
-
-  if( p->zDestTable ){
-    free(p->zDestTable);
-    p->zDestTable = 0;
-  }
-  if( zName==0 ) return;
-  needQuote = !isalpha((unsigned char)*zName) && *zName!='_';
-  for(i=n=0; zName[i]; i++, n++){
-    if( !isalnum((unsigned char)zName[i]) && zName[i]!='_' ){
-      needQuote = 1;
-      if( zName[i]=='\'' ) n++;
-    }
-  }
-  if( needQuote ) n += 2;
-  z = p->zDestTable = malloc( n+1 );
-  if( z==0 ){
-    raw_printf(stderr,"Error: out of memory\n");
-    exit(1);
-  }
-  n = 0;
-  if( needQuote ) z[n++] = '\'';
-  for(i=0; zName[i]; i++){
-    z[n++] = zName[i];
-    if( zName[i]=='\'' ) z[n++] = '\'';
-  }
-  if( needQuote ) z[n++] = '\'';
-  z[n] = 0;
-}
-
-/* zIn is either a pointer to a NULL-terminated string in memory obtained
-** from malloc(), or a NULL pointer. The string pointed to by zAppend is
-** added to zIn, and the result returned in memory obtained from malloc().
-** zIn, if it was not NULL, is freed.
-**
-** If the third argument, quote, is not '\0', then it is used as a 
-** quote character for zAppend.
-*/
-static char *appendText(char *zIn, char const *zAppend, char quote){
-  int len;
-  int i;
-  int nAppend = strlen30(zAppend);
-  int nIn = (zIn?strlen30(zIn):0);
-
-  len = nAppend+nIn+1;
-  if( quote ){
-    len += 2;
-    for(i=0; i<nAppend; i++){
-      if( zAppend[i]==quote ) len++;
-    }
-  }
-
-  zIn = (char *)realloc(zIn, len);
-  if( !zIn ){
-    return 0;
-  }
-
-  if( quote ){
-    char *zCsr = &zIn[nIn];
-    *zCsr++ = quote;
-    for(i=0; i<nAppend; i++){
-      *zCsr++ = zAppend[i];
-      if( zAppend[i]==quote ) *zCsr++ = quote;
-    }
-    *zCsr++ = quote;
-    *zCsr++ = '\0';
-    assert( (zCsr-zIn)==len );
-  }else{
-    memcpy(&zIn[nIn], zAppend, nAppend);
-    zIn[len-1] = '\0';
-  }
-
-  return zIn;
-}
-
-
-/*
-** Execute a query statement that will generate SQL output.  Print
-** the result columns, comma-separated, on a line and then add a
-** semicolon terminator to the end of that line.
-**
-** If the number of columns is 1 and that column contains text "--"
-** then write the semicolon on a separate line.  That way, if a 
-** "--" comment occurs at the end of the statement, the comment
-** won't consume the semicolon terminator.
-*/
-static int run_table_dump_query(
-  ShellState *p,           /* Query context */
-  const char *zSelect,     /* SELECT statement to extract content */
-  const char *zFirstRow    /* Print before first row, if not NULL */
-){
-  sqlite3_stmt *pSelect;
-  int rc;
-  int nResult;
-  int i;
-  const char *z;
-  rc = sqlite3_prepare_v2(p->db, zSelect, -1, &pSelect, 0);
-  if( rc!=SQLITE_OK || !pSelect ){
-    utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc,
-                sqlite3_errmsg(p->db));
-    if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
-    return rc;
-  }
-  rc = sqlite3_step(pSelect);
-  nResult = sqlite3_column_count(pSelect);
-  while( rc==SQLITE_ROW ){
-    if( zFirstRow ){
-      utf8_printf(p->out, "%s", zFirstRow);
-      zFirstRow = 0;
-    }
-    z = (const char*)sqlite3_column_text(pSelect, 0);
-    utf8_printf(p->out, "%s", z);
-    for(i=1; i<nResult; i++){ 
-      utf8_printf(p->out, ",%s", sqlite3_column_text(pSelect, i));
-    }
-    if( z==0 ) z = "";
-    while( z[0] && (z[0]!='-' || z[1]!='-') ) z++;
-    if( z[0] ){
-      raw_printf(p->out, "\n;\n");
-    }else{
-      raw_printf(p->out, ";\n");
-    }    
-    rc = sqlite3_step(pSelect);
-  }
-  rc = sqlite3_finalize(pSelect);
-  if( rc!=SQLITE_OK ){
-    utf8_printf(p->out, "/**** ERROR: (%d) %s *****/\n", rc,
-                sqlite3_errmsg(p->db));
-    if( (rc&0xff)!=SQLITE_CORRUPT ) p->nErr++;
-  }
-  return rc;
-}
-
-/*
-** Allocate space and save off current error string.
-*/
-static char *save_err_msg(
-  sqlite3 *db            /* Database to query */
-){
-  int nErrMsg = 1+strlen30(sqlite3_errmsg(db));
-  char *zErrMsg = sqlite3_malloc64(nErrMsg);
-  if( zErrMsg ){
-    memcpy(zErrMsg, sqlite3_errmsg(db), nErrMsg);
-  }
-  return zErrMsg;
-}
-
-/*
-** Display memory stats.
-*/
-static int display_stats(
-  sqlite3 *db,                /* Database to query */
-  ShellState *pArg,           /* Pointer to ShellState */
-  int bReset                  /* True to reset the stats */
-){
-  int iCur;
-  int iHiwtr;
-
-  if( pArg && pArg->out ){
-    
-    iHiwtr = iCur = -1;
-    sqlite3_status(SQLITE_STATUS_MEMORY_USED, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out,
-            "Memory Used:                         %d (max %d) bytes\n",
-            iCur, iHiwtr);
-    iHiwtr = iCur = -1;
-    sqlite3_status(SQLITE_STATUS_MALLOC_COUNT, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out, "Number of Outstanding Allocations:   %d (max %d)\n",
-            iCur, iHiwtr);
-    if( pArg->shellFlgs & SHFLG_Pagecache ){
-      iHiwtr = iCur = -1;
-      sqlite3_status(SQLITE_STATUS_PAGECACHE_USED, &iCur, &iHiwtr, bReset);
-      raw_printf(pArg->out,
-              "Number of Pcache Pages Used:         %d (max %d) pages\n",
-              iCur, iHiwtr);
-    }
-    iHiwtr = iCur = -1;
-    sqlite3_status(SQLITE_STATUS_PAGECACHE_OVERFLOW, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out,
-            "Number of Pcache Overflow Bytes:     %d (max %d) bytes\n",
-            iCur, iHiwtr);
-    if( pArg->shellFlgs & SHFLG_Scratch ){
-      iHiwtr = iCur = -1;
-      sqlite3_status(SQLITE_STATUS_SCRATCH_USED, &iCur, &iHiwtr, bReset);
-      raw_printf(pArg->out,
-              "Number of Scratch Allocations Used:  %d (max %d)\n",
-              iCur, iHiwtr);
-    }
-    iHiwtr = iCur = -1;
-    sqlite3_status(SQLITE_STATUS_SCRATCH_OVERFLOW, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out,
-            "Number of Scratch Overflow Bytes:    %d (max %d) bytes\n",
-            iCur, iHiwtr);
-    iHiwtr = iCur = -1;
-    sqlite3_status(SQLITE_STATUS_MALLOC_SIZE, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out, "Largest Allocation:                  %d bytes\n",
-            iHiwtr);
-    iHiwtr = iCur = -1;
-    sqlite3_status(SQLITE_STATUS_PAGECACHE_SIZE, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out, "Largest Pcache Allocation:           %d bytes\n",
-            iHiwtr);
-    iHiwtr = iCur = -1;
-    sqlite3_status(SQLITE_STATUS_SCRATCH_SIZE, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out, "Largest Scratch Allocation:          %d bytes\n",
-            iHiwtr);
-#ifdef YYTRACKMAXSTACKDEPTH
-    iHiwtr = iCur = -1;
-    sqlite3_status(SQLITE_STATUS_PARSER_STACK, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out, "Deepest Parser Stack:                %d (max %d)\n",
-            iCur, iHiwtr);
-#endif
-  }
-
-  if( pArg && pArg->out && db ){
-    if( pArg->shellFlgs & SHFLG_Lookaside ){
-      iHiwtr = iCur = -1;
-      sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_USED,
-                        &iCur, &iHiwtr, bReset);
-      raw_printf(pArg->out,
-              "Lookaside Slots Used:                %d (max %d)\n",
-              iCur, iHiwtr);
-      sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_HIT,
-                        &iCur, &iHiwtr, bReset);
-      raw_printf(pArg->out, "Successful lookaside attempts:       %d\n",
-              iHiwtr);
-      sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_SIZE,
-                        &iCur, &iHiwtr, bReset);
-      raw_printf(pArg->out, "Lookaside failures due to size:      %d\n",
-              iHiwtr);
-      sqlite3_db_status(db, SQLITE_DBSTATUS_LOOKASIDE_MISS_FULL,
-                        &iCur, &iHiwtr, bReset);
-      raw_printf(pArg->out, "Lookaside failures due to OOM:       %d\n",
-              iHiwtr);
-    }
-    iHiwtr = iCur = -1;
-    sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_USED, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out, "Pager Heap Usage:                    %d bytes\n",
-            iCur);
-    iHiwtr = iCur = -1;
-    sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_HIT, &iCur, &iHiwtr, 1);
-    raw_printf(pArg->out, "Page cache hits:                     %d\n", iCur);
-    iHiwtr = iCur = -1;
-    sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_MISS, &iCur, &iHiwtr, 1);
-    raw_printf(pArg->out, "Page cache misses:                   %d\n", iCur); 
-    iHiwtr = iCur = -1;
-    sqlite3_db_status(db, SQLITE_DBSTATUS_CACHE_WRITE, &iCur, &iHiwtr, 1);
-    raw_printf(pArg->out, "Page cache writes:                   %d\n", iCur); 
-    iHiwtr = iCur = -1;
-    sqlite3_db_status(db, SQLITE_DBSTATUS_SCHEMA_USED, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out, "Schema Heap Usage:                   %d bytes\n",
-            iCur); 
-    iHiwtr = iCur = -1;
-    sqlite3_db_status(db, SQLITE_DBSTATUS_STMT_USED, &iCur, &iHiwtr, bReset);
-    raw_printf(pArg->out, "Statement Heap/Lookaside Usage:      %d bytes\n",
-            iCur); 
-  }
-
-  if( pArg && pArg->out && db && pArg->pStmt ){
-    iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_FULLSCAN_STEP,
-                               bReset);
-    raw_printf(pArg->out, "Fullscan Steps:                      %d\n", iCur);
-    iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_SORT, bReset);
-    raw_printf(pArg->out, "Sort Operations:                     %d\n", iCur);
-    iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_AUTOINDEX,bReset);
-    raw_printf(pArg->out, "Autoindex Inserts:                   %d\n", iCur);
-    iCur = sqlite3_stmt_status(pArg->pStmt, SQLITE_STMTSTATUS_VM_STEP, bReset);
-    raw_printf(pArg->out, "Virtual Machine Steps:               %d\n", iCur);
-  }
-
-  /* Do not remove this machine readable comment: extra-stats-output-here */
-
-  return 0;
-}
-
-/*
-** Display scan stats.
-*/
-static void display_scanstats(
-  sqlite3 *db,                    /* Database to query */
-  ShellState *pArg                /* Pointer to ShellState */
-){
-#ifndef SQLITE_ENABLE_STMT_SCANSTATUS
-  UNUSED_PARAMETER(db);
-  UNUSED_PARAMETER(pArg);
-#else
-  int i, k, n, mx;
-  raw_printf(pArg->out, "-------- scanstats --------\n");
-  mx = 0;
-  for(k=0; k<=mx; k++){
-    double rEstLoop = 1.0;
-    for(i=n=0; 1; i++){
-      sqlite3_stmt *p = pArg->pStmt;
-      sqlite3_int64 nLoop, nVisit;
-      double rEst;
-      int iSid;
-      const char *zExplain;
-      if( sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NLOOP, (void*)&nLoop) ){
-        break;
-      }
-      sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_SELECTID, (void*)&iSid);
-      if( iSid>mx ) mx = iSid;
-      if( iSid!=k ) continue;
-      if( n==0 ){
-        rEstLoop = (double)nLoop;
-        if( k>0 ) raw_printf(pArg->out, "-------- subquery %d -------\n", k);
-      }
-      n++;
-      sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_NVISIT, (void*)&nVisit);
-      sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EST, (void*)&rEst);
-      sqlite3_stmt_scanstatus(p, i, SQLITE_SCANSTAT_EXPLAIN, (void*)&zExplain);
-      utf8_printf(pArg->out, "Loop %2d: %s\n", n, zExplain);
-      rEstLoop *= rEst;
-      raw_printf(pArg->out, 
-          "         nLoop=%-8lld nRow=%-8lld estRow=%-8lld estRow/Loop=%-8g\n",
-          nLoop, nVisit, (sqlite3_int64)(rEstLoop+0.5), rEst
-      );
-    }
-  }
-  raw_printf(pArg->out, "---------------------------\n");
-#endif
-}
-
-/*
-** Parameter azArray points to a zero-terminated array of strings. zStr
-** points to a single nul-terminated string. Return non-zero if zStr
-** is equal, according to strcmp(), to any of the strings in the array.
-** Otherwise, return zero.
-*/
-static int str_in_array(const char *zStr, const char **azArray){
-  int i;
-  for(i=0; azArray[i]; i++){
-    if( 0==strcmp(zStr, azArray[i]) ) return 1;
-  }
-  return 0;
-}
-
-/*
-** If compiled statement pSql appears to be an EXPLAIN statement, allocate
-** and populate the ShellState.aiIndent[] array with the number of
-** spaces each opcode should be indented before it is output. 
-**
-** The indenting rules are:
-**
-**     * For each "Next", "Prev", "VNext" or "VPrev" instruction, indent
-**       all opcodes that occur between the p2 jump destination and the opcode
-**       itself by 2 spaces.
-**
-**     * For each "Goto", if the jump destination is earlier in the program
-**       and ends on one of:
-**          Yield  SeekGt  SeekLt  RowSetRead  Rewind
-**       or if the P1 parameter is one instead of zero,
-**       then indent all opcodes between the earlier instruction
-**       and "Goto" by 2 spaces.
-*/
-static void explain_data_prepare(ShellState *p, sqlite3_stmt *pSql){
-  const char *zSql;               /* The text of the SQL statement */
-  const char *z;                  /* Used to check if this is an EXPLAIN */
-  int *abYield = 0;               /* True if op is an OP_Yield */
-  int nAlloc = 0;                 /* Allocated size of p->aiIndent[], abYield */
-  int iOp;                        /* Index of operation in p->aiIndent[] */
-
-  const char *azNext[] = { "Next", "Prev", "VPrev", "VNext", "SorterNext",
-                           "NextIfOpen", "PrevIfOpen", 0 };
-  const char *azYield[] = { "Yield", "SeekLT", "SeekGT", "RowSetRead",
-                            "Rewind", 0 };
-  const char *azGoto[] = { "Goto", 0 };
-
-  /* Try to figure out if this is really an EXPLAIN statement. If this
-  ** cannot be verified, return early.  */
-  zSql = sqlite3_sql(pSql);
-  if( zSql==0 ) return;
-  for(z=zSql; *z==' ' || *z=='\t' || *z=='\n' || *z=='\f' || *z=='\r'; z++);
-  if( sqlite3_strnicmp(z, "explain", 7) ) return;
-
-  for(iOp=0; SQLITE_ROW==sqlite3_step(pSql); iOp++){
-    int i;
-    int iAddr = sqlite3_column_int(pSql, 0);
-    const char *zOp = (const char*)sqlite3_column_text(pSql, 1);
-
-    /* Set p2 to the P2 field of the current opcode. Then, assuming that
-    ** p2 is an instruction address, set variable p2op to the index of that
-    ** instruction in the aiIndent[] array. p2 and p2op may be different if
-    ** the current instruction is part of a sub-program generated by an
-    ** SQL trigger or foreign key.  */
-    int p2 = sqlite3_column_int(pSql, 3);
-    int p2op = (p2 + (iOp-iAddr));
-
-    /* Grow the p->aiIndent array as required */
-    if( iOp>=nAlloc ){
-      nAlloc += 100;
-      p->aiIndent = (int*)sqlite3_realloc64(p->aiIndent, nAlloc*sizeof(int));
-      abYield = (int*)sqlite3_realloc64(abYield, nAlloc*sizeof(int));
-    }
-    abYield[iOp] = str_in_array(zOp, azYield);
-    p->aiIndent[iOp] = 0;
-    p->nIndent = iOp+1;
-
-    if( str_in_array(zOp, azNext) ){
-      for(i=p2op; i<iOp; i++) p->aiIndent[i] += 2;
-    }
-    if( str_in_array(zOp, azGoto) && p2op<p->nIndent
-     && (abYield[p2op] || sqlite3_column_int(pSql, 2))
-    ){
-      for(i=p2op+1; i<iOp; i++) p->aiIndent[i] += 2;
-    }
-  }
-
-  p->iIndent = 0;
-  sqlite3_free(abYield);
-  sqlite3_reset(pSql);
-}
-
-/*
-** Free the array allocated by explain_data_prepare().
-*/
-static void explain_data_delete(ShellState *p){
-  sqlite3_free(p->aiIndent);
-  p->aiIndent = 0;
-  p->nIndent = 0;
-  p->iIndent = 0;
-}
-
-/*
-** Execute a statement or set of statements.  Print 
-** any result rows/columns depending on the current mode 
-** set via the supplied callback.
-**
-** This is very similar to SQLite's built-in sqlite3_exec() 
-** function except it takes a slightly different callback 
-** and callback data argument.
-*/
-static int shell_exec(
-  sqlite3 *db,                              /* An open database */
-  const char *zSql,                         /* SQL to be evaluated */
-  int (*xCallback)(void*,int,char**,char**,int*),   /* Callback function */
-                                            /* (not the same as sqlite3_exec) */
-  ShellState *pArg,                         /* Pointer to ShellState */
-  char **pzErrMsg                           /* Error msg written here */
-){
-  sqlite3_stmt *pStmt = NULL;     /* Statement to execute. */
-  int rc = SQLITE_OK;             /* Return Code */
-  int rc2;
-  const char *zLeftover;          /* Tail of unprocessed SQL */
-
-  if( pzErrMsg ){
-    *pzErrMsg = NULL;
-  }
-
-  while( zSql[0] && (SQLITE_OK == rc) ){
-    rc = sqlite3_prepare_v2(db, zSql, -1, &pStmt, &zLeftover);
-    if( SQLITE_OK != rc ){
-      if( pzErrMsg ){
-        *pzErrMsg = save_err_msg(db);
-      }
-    }else{
-      if( !pStmt ){
-        /* this happens for a comment or white-space */
-        zSql = zLeftover;
-        while( IsSpace(zSql[0]) ) zSql++;
-        continue;
-      }
-
-      /* save off the prepared statment handle and reset row count */
-      if( pArg ){
-        pArg->pStmt = pStmt;
-        pArg->cnt = 0;
-      }
-
-      /* echo the sql statement if echo on */
-      if( pArg && pArg->echoOn ){
-        const char *zStmtSql = sqlite3_sql(pStmt);
-        utf8_printf(pArg->out, "%s\n", zStmtSql ? zStmtSql : zSql);
-      }
-
-      /* Show the EXPLAIN QUERY PLAN if .eqp is on */
-      if( pArg && pArg->autoEQP ){
-        sqlite3_stmt *pExplain;
-        char *zEQP = sqlite3_mprintf("EXPLAIN QUERY PLAN %s",
-                                     sqlite3_sql(pStmt));
-        rc = sqlite3_prepare_v2(db, zEQP, -1, &pExplain, 0);
-        if( rc==SQLITE_OK ){
-          while( sqlite3_step(pExplain)==SQLITE_ROW ){
-            raw_printf(pArg->out,"--EQP-- %d,",sqlite3_column_int(pExplain, 0));
-            raw_printf(pArg->out,"%d,", sqlite3_column_int(pExplain, 1));
-            raw_printf(pArg->out,"%d,", sqlite3_column_int(pExplain, 2));
-            utf8_printf(pArg->out,"%s\n", sqlite3_column_text(pExplain, 3));
-          }
-        }
-        sqlite3_finalize(pExplain);
-        sqlite3_free(zEQP);
-      }
-
-      /* If the shell is currently in ".explain" mode, gather the extra
-      ** data required to add indents to the output.*/
-      if( pArg && pArg->mode==MODE_Explain ){
-        explain_data_prepare(pArg, pStmt);
-      }
-
-      /* perform the first step.  this will tell us if we
-      ** have a result set or not and how wide it is.
-      */
-      rc = sqlite3_step(pStmt);
-      /* if we have a result set... */
-      if( SQLITE_ROW == rc ){
-        /* if we have a callback... */
-        if( xCallback ){
-          /* allocate space for col name ptr, value ptr, and type */
-          int nCol = sqlite3_column_count(pStmt);
-          void *pData = sqlite3_malloc64(3*nCol*sizeof(const char*) + 1);
-          if( !pData ){
-            rc = SQLITE_NOMEM;
-          }else{
-            char **azCols = (char **)pData;      /* Names of result columns */
-            char **azVals = &azCols[nCol];       /* Results */
-            int *aiTypes = (int *)&azVals[nCol]; /* Result types */
-            int i, x;
-            assert(sizeof(int) <= sizeof(char *)); 
-            /* save off ptrs to column names */
-            for(i=0; i<nCol; i++){
-              azCols[i] = (char *)sqlite3_column_name(pStmt, i);
-            }
-            do{
-              /* extract the data and data types */
-              for(i=0; i<nCol; i++){
-                aiTypes[i] = x = sqlite3_column_type(pStmt, i);
-                if( x==SQLITE_BLOB && pArg && pArg->mode==MODE_Insert ){
-                  azVals[i] = "";
-                }else{
-                  azVals[i] = (char*)sqlite3_column_text(pStmt, i);
-                }
-                if( !azVals[i] && (aiTypes[i]!=SQLITE_NULL) ){
-                  rc = SQLITE_NOMEM;
-                  break; /* from for */
-                }
-              } /* end for */
-
-              /* if data and types extracted successfully... */
-              if( SQLITE_ROW == rc ){ 
-                /* call the supplied callback with the result row data */
-                if( xCallback(pArg, nCol, azVals, azCols, aiTypes) ){
-                  rc = SQLITE_ABORT;
-                }else{
-                  rc = sqlite3_step(pStmt);
-                }
-              }
-            } while( SQLITE_ROW == rc );
-            sqlite3_free(pData);
-          }
-        }else{
-          do{
-            rc = sqlite3_step(pStmt);
-          } while( rc == SQLITE_ROW );
-        }
-      }
-
-      explain_data_delete(pArg);
-
-      /* print usage stats if stats on */
-      if( pArg && pArg->statsOn ){
-        display_stats(db, pArg, 0);
-      }
-
-      /* print loop-counters if required */
-      if( pArg && pArg->scanstatsOn ){
-        display_scanstats(db, pArg);
-      }
-
-      /* Finalize the statement just executed. If this fails, save a 
-      ** copy of the error message. Otherwise, set zSql to point to the
-      ** next statement to execute. */
-      rc2 = sqlite3_finalize(pStmt);
-      if( rc!=SQLITE_NOMEM ) rc = rc2;
-      if( rc==SQLITE_OK ){
-        zSql = zLeftover;
-        while( IsSpace(zSql[0]) ) zSql++;
-      }else if( pzErrMsg ){
-        *pzErrMsg = save_err_msg(db);
-      }
-
-      /* clear saved stmt handle */
-      if( pArg ){
-        pArg->pStmt = NULL;
-      }
-    }
-  } /* end while */
-
-  return rc;
-}
-
-
-/*
-** This is a different callback routine used for dumping the database.
-** Each row received by this callback consists of a table name,
-** the table type ("index" or "table") and SQL to create the table.
-** This routine should print text sufficient to recreate the table.
-*/
-static int dump_callback(void *pArg, int nArg, char **azArg, char **azCol){
-  int rc;
-  const char *zTable;
-  const char *zType;
-  const char *zSql;
-  const char *zPrepStmt = 0;
-  ShellState *p = (ShellState *)pArg;
-
-  UNUSED_PARAMETER(azCol);
-  if( nArg!=3 ) return 1;
-  zTable = azArg[0];
-  zType = azArg[1];
-  zSql = azArg[2];
-  
-  if( strcmp(zTable, "sqlite_sequence")==0 ){
-    zPrepStmt = "DELETE FROM sqlite_sequence;\n";
-  }else if( sqlite3_strglob("sqlite_stat?", zTable)==0 ){
-    raw_printf(p->out, "ANALYZE sqlite_master;\n");
-  }else if( strncmp(zTable, "sqlite_", 7)==0 ){
-    return 0;
-  }else if( strncmp(zSql, "CREATE VIRTUAL TABLE", 20)==0 ){
-    char *zIns;
-    if( !p->writableSchema ){
-      raw_printf(p->out, "PRAGMA writable_schema=ON;\n");
-      p->writableSchema = 1;
-    }
-    zIns = sqlite3_mprintf(
-       "INSERT INTO sqlite_master(type,name,tbl_name,rootpage,sql)"
-       "VALUES('table','%q','%q',0,'%q');",
-       zTable, zTable, zSql);
-    utf8_printf(p->out, "%s\n", zIns);
-    sqlite3_free(zIns);
-    return 0;
-  }else{
-    utf8_printf(p->out, "%s;\n", zSql);
-  }
-
-  if( strcmp(zType, "table")==0 ){
-    sqlite3_stmt *pTableInfo = 0;
-    char *zSelect = 0;
-    char *zTableInfo = 0;
-    char *zTmp = 0;
-    int nRow = 0;
-   
-    zTableInfo = appendText(zTableInfo, "PRAGMA table_info(", 0);
-    zTableInfo = appendText(zTableInfo, zTable, '"');
-    zTableInfo = appendText(zTableInfo, ");", 0);
-
-    rc = sqlite3_prepare_v2(p->db, zTableInfo, -1, &pTableInfo, 0);
-    free(zTableInfo);
-    if( rc!=SQLITE_OK || !pTableInfo ){
-      return 1;
-    }
-
-    zSelect = appendText(zSelect, "SELECT 'INSERT INTO ' || ", 0);
-    /* Always quote the table name, even if it appears to be pure ascii,
-    ** in case it is a keyword. Ex:  INSERT INTO "table" ... */
-    zTmp = appendText(zTmp, zTable, '"');
-    if( zTmp ){
-      zSelect = appendText(zSelect, zTmp, '\'');
-      free(zTmp);
-    }
-    zSelect = appendText(zSelect, " || ' VALUES(' || ", 0);
-    rc = sqlite3_step(pTableInfo);
-    while( rc==SQLITE_ROW ){
-      const char *zText = (const char *)sqlite3_column_text(pTableInfo, 1);
-      zSelect = appendText(zSelect, "quote(", 0);
-      zSelect = appendText(zSelect, zText, '"');
-      rc = sqlite3_step(pTableInfo);
-      if( rc==SQLITE_ROW ){
-        zSelect = appendText(zSelect, "), ", 0);
-      }else{
-        zSelect = appendText(zSelect, ") ", 0);
-      }
-      nRow++;
-    }
-    rc = sqlite3_finalize(pTableInfo);
-    if( rc!=SQLITE_OK || nRow==0 ){
-      free(zSelect);
-      return 1;
-    }
-    zSelect = appendText(zSelect, "|| ')' FROM  ", 0);
-    zSelect = appendText(zSelect, zTable, '"');
-
-    rc = run_table_dump_query(p, zSelect, zPrepStmt);
-    if( rc==SQLITE_CORRUPT ){
-      zSelect = appendText(zSelect, " ORDER BY rowid DESC", 0);
-      run_table_dump_query(p, zSelect, 0);
-    }
-    free(zSelect);
-  }
-  return 0;
-}
-
-/*
-** Run zQuery.  Use dump_callback() as the callback routine so that
-** the contents of the query are output as SQL statements.
-**
-** If we get a SQLITE_CORRUPT error, rerun the query after appending
-** "ORDER BY rowid DESC" to the end.
-*/
-static int run_schema_dump_query(
-  ShellState *p, 
-  const char *zQuery
-){
-  int rc;
-  char *zErr = 0;
-  rc = sqlite3_exec(p->db, zQuery, dump_callback, p, &zErr);
-  if( rc==SQLITE_CORRUPT ){
-    char *zQ2;
-    int len = strlen30(zQuery);
-    raw_printf(p->out, "/****** CORRUPTION ERROR *******/\n");
-    if( zErr ){
-      utf8_printf(p->out, "/****** %s ******/\n", zErr);
-      sqlite3_free(zErr);
-      zErr = 0;
-    }
-    zQ2 = malloc( len+100 );
-    if( zQ2==0 ) return rc;
-    sqlite3_snprintf(len+100, zQ2, "%s ORDER BY rowid DESC", zQuery);
-    rc = sqlite3_exec(p->db, zQ2, dump_callback, p, &zErr);
-    if( rc ){
-      utf8_printf(p->out, "/****** ERROR: %s ******/\n", zErr);
-    }else{
-      rc = SQLITE_CORRUPT;
-    }
-    sqlite3_free(zErr);
-    free(zQ2);
-  }
-  return rc;
-}
-
-/*
-** Text of a help message
-*/
-static char zHelp[] =
-  ".backup ?DB? FILE      Backup DB (default \"main\") to FILE\n"
-  ".bail on|off           Stop after hitting an error.  Default OFF\n"
-  ".binary on|off         Turn binary output on or off.  Default OFF\n"
-  ".changes on|off        Show number of rows changed by SQL\n"
-  ".clone NEWDB           Clone data into NEWDB from the existing database\n"
-  ".databases             List names and files of attached databases\n"
-  ".dbinfo ?DB?           Show status information about the database\n"
-  ".dump ?TABLE? ...      Dump the database in an SQL text format\n"
-  "                         If TABLE specified, only dump tables matching\n"
-  "                         LIKE pattern TABLE.\n"
-  ".echo on|off           Turn command echo on or off\n"
-  ".eqp on|off            Enable or disable automatic EXPLAIN QUERY PLAN\n"
-  ".exit                  Exit this program\n"
-  ".explain ?on|off?      Turn output mode suitable for EXPLAIN on or off.\n"
-  "                         With no args, it turns EXPLAIN on.\n"
-  ".fullschema            Show schema and the content of sqlite_stat tables\n"
-  ".headers on|off        Turn display of headers on or off\n"
-  ".help                  Show this message\n"
-  ".import FILE TABLE     Import data from FILE into TABLE\n"
-  ".indexes ?TABLE?       Show names of all indexes\n"
-  "                         If TABLE specified, only show indexes for tables\n"
-  "                         matching LIKE pattern TABLE.\n"
-#ifdef SQLITE_ENABLE_IOTRACE
-  ".iotrace FILE          Enable I/O diagnostic logging to FILE\n"
-#endif
-  ".limit ?LIMIT? ?VAL?   Display or change the value of an SQLITE_LIMIT\n"
-#ifndef SQLITE_OMIT_LOAD_EXTENSION
-  ".load FILE ?ENTRY?     Load an extension library\n"
-#endif
-  ".log FILE|off          Turn logging on or off.  FILE can be stderr/stdout\n"
-  ".mode MODE ?TABLE?     Set output mode where MODE is one of:\n"
-  "                         ascii    Columns/rows delimited by 0x1F and 0x1E\n"
-  "                         csv      Comma-separated values\n"
-  "                         column   Left-aligned columns.  (See .width)\n"
-  "                         html     HTML <table> code\n"
-  "                         insert   SQL insert statements for TABLE\n"
-  "                         line     One value per line\n"
-  "                         list     Values delimited by .separator strings\n"
-  "                         tabs     Tab-separated values\n"
-  "                         tcl      TCL list elements\n"
-  ".nullvalue STRING      Use STRING in place of NULL values\n"
-  ".once FILENAME         Output for the next SQL command only to FILENAME\n"
-  ".open ?FILENAME?       Close existing database and reopen FILENAME\n"
-  ".output ?FILENAME?     Send output to FILENAME or stdout\n"
-  ".print STRING...       Print literal STRING\n"
-  ".prompt MAIN CONTINUE  Replace the standard prompts\n"
-  ".quit                  Exit this program\n"
-  ".read FILENAME         Execute SQL in FILENAME\n"
-  ".restore ?DB? FILE     Restore content of DB (default \"main\") from FILE\n"
-  ".save FILE             Write in-memory database into FILE\n"
-  ".scanstats on|off      Turn sqlite3_stmt_scanstatus() metrics on or off\n"
-  ".schema ?TABLE?        Show the CREATE statements\n"
-  "                         If TABLE specified, only show tables matching\n"
-  "                         LIKE pattern TABLE.\n"
-  ".separator COL ?ROW?   Change the column separator and optionally the row\n"
-  "                         separator for both the output mode and .import\n"
-  ".shell CMD ARGS...     Run CMD ARGS... in a system shell\n"
-  ".show                  Show the current values for various settings\n"
-  ".stats on|off          Turn stats on or off\n"
-  ".system CMD ARGS...    Run CMD ARGS... in a system shell\n"
-  ".tables ?TABLE?        List names of tables\n"
-  "                         If TABLE specified, only list tables matching\n"
-  "                         LIKE pattern TABLE.\n"
-  ".timeout MS            Try opening locked tables for MS milliseconds\n"
-  ".timer on|off          Turn SQL timer on or off\n"
-  ".trace FILE|off        Output each SQL statement as it is run\n"
-  ".vfsinfo ?AUX?         Information about the top-level VFS\n"
-  ".vfsname ?AUX?         Print the name of the VFS stack\n"
-  ".width NUM1 NUM2 ...   Set column widths for \"column\" mode\n"
-  "                         Negative values right-justify\n"
-;
-
-/* Forward reference */
-static int process_input(ShellState *p, FILE *in);
-/*
-** Implementation of the "readfile(X)" SQL function.  The entire content
-** of the file named X is read and returned as a BLOB.  NULL is returned
-** if the file does not exist or is unreadable.
-*/
-static void readfileFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  const char *zName;
-  FILE *in;
-  long nIn;
-  void *pBuf;
-
-  UNUSED_PARAMETER(argc);
-  zName = (const char*)sqlite3_value_text(argv[0]);
-  if( zName==0 ) return;
-  in = fopen(zName, "rb");
-  if( in==0 ) return;
-  fseek(in, 0, SEEK_END);
-  nIn = ftell(in);
-  rewind(in);
-  pBuf = sqlite3_malloc64( nIn );
-  if( pBuf && 1==fread(pBuf, nIn, 1, in) ){
-    sqlite3_result_blob(context, pBuf, nIn, sqlite3_free);
-  }else{
-    sqlite3_free(pBuf);
-  }
-  fclose(in);
-}
-
-/*
-** Implementation of the "writefile(X,Y)" SQL function.  The argument Y
-** is written into file X.  The number of bytes written is returned.  Or
-** NULL is returned if something goes wrong, such as being unable to open
-** file X for writing.
-*/
-static void writefileFunc(
-  sqlite3_context *context,
-  int argc,
-  sqlite3_value **argv
-){
-  FILE *out;
-  const char *z;
-  sqlite3_int64 rc;
-  const char *zFile;
-
-  UNUSED_PARAMETER(argc);
-  zFile = (const char*)sqlite3_value_text(argv[0]);
-  if( zFile==0 ) return;
-  out = fopen(zFile, "wb");
-  if( out==0 ) return;
-  z = (const char*)sqlite3_value_blob(argv[1]);
-  if( z==0 ){
-    rc = 0;
-  }else{
-    rc = fwrite(z, 1, sqlite3_value_bytes(argv[1]), out);
-  }
-  fclose(out);
-  sqlite3_result_int64(context, rc);
-}
-
-/*
-** Make sure the database is open.  If it is not, then open it.  If
-** the database fails to open, print an error message and exit.
-*/
-static void open_db(ShellState *p, int keepAlive){
-  if( p->db==0 ){
-    sqlite3_initialize();
-    sqlite3_open(p->zDbFilename, &p->db);
-    globalDb = p->db;
-    if( p->db && sqlite3_errcode(p->db)==SQLITE_OK ){
-      sqlite3_create_function(p->db, "shellstatic", 0, SQLITE_UTF8, 0,
-          shellstaticFunc, 0, 0);
-    }
-    if( p->db==0 || SQLITE_OK!=sqlite3_errcode(p->db) ){
-      utf8_printf(stderr,"Error: unable to open database \"%s\": %s\n", 
-          p->zDbFilename, sqlite3_errmsg(p->db));
-      if( keepAlive ) return;
-      exit(1);
-    }
-#ifndef SQLITE_OMIT_LOAD_EXTENSION
-    sqlite3_enable_load_extension(p->db, 1);
-#endif
-    sqlite3_create_function(p->db, "readfile", 1, SQLITE_UTF8, 0,
-                            readfileFunc, 0, 0);
-    sqlite3_create_function(p->db, "writefile", 2, SQLITE_UTF8, 0,
-                            writefileFunc, 0, 0);
-  }
-}
-
-/*
-** Do C-language style dequoting.
-**
-**    \a    -> alarm
-**    \b    -> backspace
-**    \t    -> tab
-**    \n    -> newline
-**    \v    -> vertical tab
-**    \f    -> form feed
-**    \r    -> carriage return
-**    \s    -> space
-**    \"    -> "
-**    \'    -> '
-**    \\    -> backslash
-**    \NNN  -> ascii character NNN in octal
-*/
-static void resolve_backslashes(char *z){
-  int i, j;
-  char c;
-  while( *z && *z!='\\' ) z++;
-  for(i=j=0; (c = z[i])!=0; i++, j++){
-    if( c=='\\' && z[i+1]!=0 ){
-      c = z[++i];
-      if( c=='a' ){
-        c = '\a';
-      }else if( c=='b' ){
-        c = '\b';
-      }else if( c=='t' ){
-        c = '\t';
-      }else if( c=='n' ){
-        c = '\n';
-      }else if( c=='v' ){
-        c = '\v';
-      }else if( c=='f' ){
-        c = '\f';
-      }else if( c=='r' ){
-        c = '\r';
-      }else if( c=='"' ){
-        c = '"';
-      }else if( c=='\'' ){
-        c = '\'';
-      }else if( c=='\\' ){
-        c = '\\';
-      }else if( c>='0' && c<='7' ){
-        c -= '0';
-        if( z[i+1]>='0' && z[i+1]<='7' ){
-          i++;
-          c = (c<<3) + z[i] - '0';
-          if( z[i+1]>='0' && z[i+1]<='7' ){
-            i++;
-            c = (c<<3) + z[i] - '0';
-          }
-        }
-      }
-    }
-    z[j] = c;
-  }
-  if( j<i ) z[j] = 0;
-}
-
-/*
-** Return the value of a hexadecimal digit.  Return -1 if the input
-** is not a hex digit.
-*/
-static int hexDigitValue(char c){
-  if( c>='0' && c<='9' ) return c - '0';
-  if( c>='a' && c<='f' ) return c - 'a' + 10;
-  if( c>='A' && c<='F' ) return c - 'A' + 10;
-  return -1;
-}
-
-/*
-** Interpret zArg as an integer value, possibly with suffixes.
-*/
-static sqlite3_int64 integerValue(const char *zArg){
-  sqlite3_int64 v = 0;
-  static const struct { char *zSuffix; int iMult; } aMult[] = {
-    { "KiB", 1024 },
-    { "MiB", 1024*1024 },
-    { "GiB", 1024*1024*1024 },
-    { "KB",  1000 },
-    { "MB",  1000000 },
-    { "GB",  1000000000 },
-    { "K",   1000 },
-    { "M",   1000000 },
-    { "G",   1000000000 },
-  };
-  int i;
-  int isNeg = 0;
-  if( zArg[0]=='-' ){
-    isNeg = 1;
-    zArg++;
-  }else if( zArg[0]=='+' ){
-    zArg++;
-  }
-  if( zArg[0]=='0' && zArg[1]=='x' ){
-    int x;
-    zArg += 2;
-    while( (x = hexDigitValue(zArg[0]))>=0 ){
-      v = (v<<4) + x;
-      zArg++;
-    }
-  }else{
-    while( IsDigit(zArg[0]) ){
-      v = v*10 + zArg[0] - '0';
-      zArg++;
-    }
-  }
-  for(i=0; i<ArraySize(aMult); i++){
-    if( sqlite3_stricmp(aMult[i].zSuffix, zArg)==0 ){
-      v *= aMult[i].iMult;
-      break;
-    }
-  }
-  return isNeg? -v : v;
-}
-
-/*
-** Interpret zArg as either an integer or a boolean value.  Return 1 or 0
-** for TRUE and FALSE.  Return the integer value if appropriate.
-*/
-static int booleanValue(char *zArg){
-  int i;
-  if( zArg[0]=='0' && zArg[1]=='x' ){
-    for(i=2; hexDigitValue(zArg[i])>=0; i++){}
-  }else{
-    for(i=0; zArg[i]>='0' && zArg[i]<='9'; i++){}
-  }
-  if( i>0 && zArg[i]==0 ) return (int)(integerValue(zArg) & 0xffffffff);
-  if( sqlite3_stricmp(zArg, "on")==0 || sqlite3_stricmp(zArg,"yes")==0 ){
-    return 1;
-  }
-  if( sqlite3_stricmp(zArg, "off")==0 || sqlite3_stricmp(zArg,"no")==0 ){
-    return 0;
-  }
-  utf8_printf(stderr, "ERROR: Not a boolean value: \"%s\". Assuming \"no\".\n",
-          zArg);
-  return 0;
-}
-
-/*
-** Close an output file, assuming it is not stderr or stdout
-*/
-static void output_file_close(FILE *f){
-  if( f && f!=stdout && f!=stderr ) fclose(f);
-}
-
-/*
-** Try to open an output file.   The names "stdout" and "stderr" are
-** recognized and do the right thing.  NULL is returned if the output 
-** filename is "off".
-*/
-static FILE *output_file_open(const char *zFile){
-  FILE *f;
-  if( strcmp(zFile,"stdout")==0 ){
-    f = stdout;
-  }else if( strcmp(zFile, "stderr")==0 ){
-    f = stderr;
-  }else if( strcmp(zFile, "off")==0 ){
-    f = 0;
-  }else{
-    f = fopen(zFile, "wb");
-    if( f==0 ){
-      utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile);
-    }
-  }
-  return f;
-}
-
-/*
-** A routine for handling output from sqlite3_trace().
-*/
-static void sql_trace_callback(void *pArg, const char *z){
-  FILE *f = (FILE*)pArg;
-  if( f ){
-    int i = (int)strlen(z);
-    while( i>0 && z[i-1]==';' ){ i--; }
-    utf8_printf(f, "%.*s;\n", i, z);
-  }
-}
-
-/*
-** A no-op routine that runs with the ".breakpoint" doc-command.  This is
-** a useful spot to set a debugger breakpoint.
-*/
-static void test_breakpoint(void){
-  static int nCall = 0;
-  nCall++;
-}
-
-/*
-** An object used to read a CSV and other files for import.
-*/
-typedef struct ImportCtx ImportCtx;
-struct ImportCtx {
-  const char *zFile;  /* Name of the input file */
-  FILE *in;           /* Read the CSV text from this input stream */
-  char *z;            /* Accumulated text for a field */
-  int n;              /* Number of bytes in z */
-  int nAlloc;         /* Space allocated for z[] */
-  int nLine;          /* Current line number */
-  int cTerm;          /* Character that terminated the most recent field */
-  int cColSep;        /* The column separator character.  (Usually ",") */
-  int cRowSep;        /* The row separator character.  (Usually "\n") */
-};
-
-/* Append a single byte to z[] */
-static void import_append_char(ImportCtx *p, int c){
-  if( p->n+1>=p->nAlloc ){
-    p->nAlloc += p->nAlloc + 100;
-    p->z = sqlite3_realloc64(p->z, p->nAlloc);
-    if( p->z==0 ){
-      raw_printf(stderr, "out of memory\n");
-      exit(1);
-    }
-  }
-  p->z[p->n++] = (char)c;
-}
-
-/* Read a single field of CSV text.  Compatible with rfc4180 and extended
-** with the option of having a separator other than ",".
-**
-**   +  Input comes from p->in.
-**   +  Store results in p->z of length p->n.  Space to hold p->z comes
-**      from sqlite3_malloc64().
-**   +  Use p->cSep as the column separator.  The default is ",".
-**   +  Use p->rSep as the row separator.  The default is "\n".
-**   +  Keep track of the line number in p->nLine.
-**   +  Store the character that terminates the field in p->cTerm.  Store
-**      EOF on end-of-file.
-**   +  Report syntax errors on stderr
-*/
-static char *SQLITE_CDECL csv_read_one_field(ImportCtx *p){
-  int c;
-  int cSep = p->cColSep;
-  int rSep = p->cRowSep;
-  p->n = 0;
-  c = fgetc(p->in);
-  if( c==EOF || seenInterrupt ){
-    p->cTerm = EOF;
-    return 0;
-  }
-  if( c=='"' ){
-    int pc, ppc;
-    int startLine = p->nLine;
-    int cQuote = c;
-    pc = ppc = 0;
-    while( 1 ){
-      c = fgetc(p->in);
-      if( c==rSep ) p->nLine++;
-      if( c==cQuote ){
-        if( pc==cQuote ){
-          pc = 0;
-          continue;
-        }
-      }
-      if( (c==cSep && pc==cQuote)
-       || (c==rSep && pc==cQuote)
-       || (c==rSep && pc=='\r' && ppc==cQuote)
-       || (c==EOF && pc==cQuote)
-      ){
-        do{ p->n--; }while( p->z[p->n]!=cQuote );
-        p->cTerm = c;
-        break;
-      }
-      if( pc==cQuote && c!='\r' ){
-        utf8_printf(stderr, "%s:%d: unescaped %c character\n",
-                p->zFile, p->nLine, cQuote);
-      }
-      if( c==EOF ){
-        utf8_printf(stderr, "%s:%d: unterminated %c-quoted field\n",
-                p->zFile, startLine, cQuote);
-        p->cTerm = c;
-        break;
-      }
-      import_append_char(p, c);
-      ppc = pc;
-      pc = c;
-    }
-  }else{
-    while( c!=EOF && c!=cSep && c!=rSep ){
-      import_append_char(p, c);
-      c = fgetc(p->in);
-    }
-    if( c==rSep ){
-      p->nLine++;
-      if( p->n>0 && p->z[p->n-1]=='\r' ) p->n--;
-    }
-    p->cTerm = c;
-  }
-  if( p->z ) p->z[p->n] = 0;
-  return p->z;
-}
-
-/* Read a single field of ASCII delimited text.
-**
-**   +  Input comes from p->in.
-**   +  Store results in p->z of length p->n.  Space to hold p->z comes
-**      from sqlite3_malloc64().
-**   +  Use p->cSep as the column separator.  The default is "\x1F".
-**   +  Use p->rSep as the row separator.  The default is "\x1E".
-**   +  Keep track of the row number in p->nLine.
-**   +  Store the character that terminates the field in p->cTerm.  Store
-**      EOF on end-of-file.
-**   +  Report syntax errors on stderr
-*/
-static char *SQLITE_CDECL ascii_read_one_field(ImportCtx *p){
-  int c;
-  int cSep = p->cColSep;
-  int rSep = p->cRowSep;
-  p->n = 0;
-  c = fgetc(p->in);
-  if( c==EOF || seenInterrupt ){
-    p->cTerm = EOF;
-    return 0;
-  }
-  while( c!=EOF && c!=cSep && c!=rSep ){
-    import_append_char(p, c);
-    c = fgetc(p->in);
-  }
-  if( c==rSep ){
-    p->nLine++;
-  }
-  p->cTerm = c;
-  if( p->z ) p->z[p->n] = 0;
-  return p->z;
-}
-
-/*
-** Try to transfer data for table zTable.  If an error is seen while
-** moving forward, try to go backwards.  The backwards movement won't
-** work for WITHOUT ROWID tables.
-*/
-static void tryToCloneData(
-  ShellState *p,
-  sqlite3 *newDb,
-  const char *zTable
-){
-  sqlite3_stmt *pQuery = 0; 
-  sqlite3_stmt *pInsert = 0;
-  char *zQuery = 0;
-  char *zInsert = 0;
-  int rc;
-  int i, j, n;
-  int nTable = (int)strlen(zTable);
-  int k = 0;
-  int cnt = 0;
-  const int spinRate = 10000;
-
-  zQuery = sqlite3_mprintf("SELECT * FROM \"%w\"", zTable);
-  rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
-  if( rc ){
-    utf8_printf(stderr, "Error %d: %s on [%s]\n",
-            sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
-            zQuery);
-    goto end_data_xfer;
-  }
-  n = sqlite3_column_count(pQuery);
-  zInsert = sqlite3_malloc64(200 + nTable + n*3);
-  if( zInsert==0 ){
-    raw_printf(stderr, "out of memory\n");
-    goto end_data_xfer;
-  }
-  sqlite3_snprintf(200+nTable,zInsert,
-                   "INSERT OR IGNORE INTO \"%s\" VALUES(?", zTable);
-  i = (int)strlen(zInsert);
-  for(j=1; j<n; j++){
-    memcpy(zInsert+i, ",?", 2);
-    i += 2;
-  }
-  memcpy(zInsert+i, ");", 3);
-  rc = sqlite3_prepare_v2(newDb, zInsert, -1, &pInsert, 0);
-  if( rc ){
-    utf8_printf(stderr, "Error %d: %s on [%s]\n",
-            sqlite3_extended_errcode(newDb), sqlite3_errmsg(newDb),
-            zQuery);
-    goto end_data_xfer;
-  }
-  for(k=0; k<2; k++){
-    while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
-      for(i=0; i<n; i++){
-        switch( sqlite3_column_type(pQuery, i) ){
-          case SQLITE_NULL: {
-            sqlite3_bind_null(pInsert, i+1);
-            break;
-          }
-          case SQLITE_INTEGER: {
-            sqlite3_bind_int64(pInsert, i+1, sqlite3_column_int64(pQuery,i));
-            break;
-          }
-          case SQLITE_FLOAT: {
-            sqlite3_bind_double(pInsert, i+1, sqlite3_column_double(pQuery,i));
-            break;
-          }
-          case SQLITE_TEXT: {
-            sqlite3_bind_text(pInsert, i+1,
-                             (const char*)sqlite3_column_text(pQuery,i),
-                             -1, SQLITE_STATIC);
-            break;
-          }
-          case SQLITE_BLOB: {
-            sqlite3_bind_blob(pInsert, i+1, sqlite3_column_blob(pQuery,i),
-                                            sqlite3_column_bytes(pQuery,i),
-                                            SQLITE_STATIC);
-            break;
-          }
-        }
-      } /* End for */
-      rc = sqlite3_step(pInsert);
-      if( rc!=SQLITE_OK && rc!=SQLITE_ROW && rc!=SQLITE_DONE ){
-        utf8_printf(stderr, "Error %d: %s\n", sqlite3_extended_errcode(newDb),
-                        sqlite3_errmsg(newDb));
-      }
-      sqlite3_reset(pInsert);
-      cnt++;
-      if( (cnt%spinRate)==0 ){
-        printf("%c\b", "|/-\\"[(cnt/spinRate)%4]);
-        fflush(stdout);
-      }
-    } /* End while */
-    if( rc==SQLITE_DONE ) break;
-    sqlite3_finalize(pQuery);
-    sqlite3_free(zQuery);
-    zQuery = sqlite3_mprintf("SELECT * FROM \"%w\" ORDER BY rowid DESC;",
-                             zTable);
-    rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
-    if( rc ){
-      utf8_printf(stderr, "Warning: cannot step \"%s\" backwards", zTable);
-      break;
-    }
-  } /* End for(k=0...) */
-
-end_data_xfer:
-  sqlite3_finalize(pQuery);
-  sqlite3_finalize(pInsert);
-  sqlite3_free(zQuery);
-  sqlite3_free(zInsert);
-}
-
-
-/*
-** Try to transfer all rows of the schema that match zWhere.  For
-** each row, invoke xForEach() on the object defined by that row.
-** If an error is encountered while moving forward through the
-** sqlite_master table, try again moving backwards.
-*/
-static void tryToCloneSchema(
-  ShellState *p,
-  sqlite3 *newDb,
-  const char *zWhere,
-  void (*xForEach)(ShellState*,sqlite3*,const char*)
-){
-  sqlite3_stmt *pQuery = 0;
-  char *zQuery = 0;
-  int rc;
-  const unsigned char *zName;
-  const unsigned char *zSql;
-  char *zErrMsg = 0;
-
-  zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
-                           " WHERE %s", zWhere);
-  rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
-  if( rc ){
-    utf8_printf(stderr, "Error: (%d) %s on [%s]\n",
-                    sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
-                    zQuery);
-    goto end_schema_xfer;
-  }
-  while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
-    zName = sqlite3_column_text(pQuery, 0);
-    zSql = sqlite3_column_text(pQuery, 1);
-    printf("%s... ", zName); fflush(stdout);
-    sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
-    if( zErrMsg ){
-      utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
-      sqlite3_free(zErrMsg);
-      zErrMsg = 0;
-    }
-    if( xForEach ){
-      xForEach(p, newDb, (const char*)zName);
-    }
-    printf("done\n");
-  }
-  if( rc!=SQLITE_DONE ){
-    sqlite3_finalize(pQuery);
-    sqlite3_free(zQuery);
-    zQuery = sqlite3_mprintf("SELECT name, sql FROM sqlite_master"
-                             " WHERE %s ORDER BY rowid DESC", zWhere);
-    rc = sqlite3_prepare_v2(p->db, zQuery, -1, &pQuery, 0);
-    if( rc ){
-      utf8_printf(stderr, "Error: (%d) %s on [%s]\n",
-                      sqlite3_extended_errcode(p->db), sqlite3_errmsg(p->db),
-                      zQuery);
-      goto end_schema_xfer;
-    }
-    while( (rc = sqlite3_step(pQuery))==SQLITE_ROW ){
-      zName = sqlite3_column_text(pQuery, 0);
-      zSql = sqlite3_column_text(pQuery, 1);
-      printf("%s... ", zName); fflush(stdout);
-      sqlite3_exec(newDb, (const char*)zSql, 0, 0, &zErrMsg);
-      if( zErrMsg ){
-        utf8_printf(stderr, "Error: %s\nSQL: [%s]\n", zErrMsg, zSql);
-        sqlite3_free(zErrMsg);
-        zErrMsg = 0;
-      }
-      if( xForEach ){
-        xForEach(p, newDb, (const char*)zName);
-      }
-      printf("done\n");
-    }
-  }
-end_schema_xfer:
-  sqlite3_finalize(pQuery);
-  sqlite3_free(zQuery);
-}
-
-/*
-** Open a new database file named "zNewDb".  Try to recover as much information
-** as possible out of the main database (which might be corrupt) and write it
-** into zNewDb.
-*/
-static void tryToClone(ShellState *p, const char *zNewDb){
-  int rc;
-  sqlite3 *newDb = 0;
-  if( access(zNewDb,0)==0 ){
-    utf8_printf(stderr, "File \"%s\" already exists.\n", zNewDb);
-    return;
-  }
-  rc = sqlite3_open(zNewDb, &newDb);
-  if( rc ){
-    utf8_printf(stderr, "Cannot create output database: %s\n",
-            sqlite3_errmsg(newDb));
-  }else{
-    sqlite3_exec(p->db, "PRAGMA writable_schema=ON;", 0, 0, 0);
-    sqlite3_exec(newDb, "BEGIN EXCLUSIVE;", 0, 0, 0);
-    tryToCloneSchema(p, newDb, "type='table'", tryToCloneData);
-    tryToCloneSchema(p, newDb, "type!='table'", 0);
-    sqlite3_exec(newDb, "COMMIT;", 0, 0, 0);
-    sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
-  }
-  sqlite3_close(newDb);
-}
-
-/*
-** Change the output file back to stdout
-*/
-static void output_reset(ShellState *p){
-  if( p->outfile[0]=='|' ){
-#ifndef SQLITE_OMIT_POPEN
-    pclose(p->out);
-#endif
-  }else{
-    output_file_close(p->out);
-  }
-  p->outfile[0] = 0;
-  p->out = stdout;
-}
-
-/*
-** Run an SQL command and return the single integer result.
-*/
-static int db_int(ShellState *p, const char *zSql){
-  sqlite3_stmt *pStmt;
-  int res = 0;
-  sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
-  if( pStmt && sqlite3_step(pStmt)==SQLITE_ROW ){
-    res = sqlite3_column_int(pStmt,0);
-  }
-  sqlite3_finalize(pStmt);
-  return res;
-}
-
-/*
-** Convert a 2-byte or 4-byte big-endian integer into a native integer
-*/
-unsigned int get2byteInt(unsigned char *a){
-  return (a[0]<<8) + a[1];
-}
-unsigned int get4byteInt(unsigned char *a){
-  return (a[0]<<24) + (a[1]<<16) + (a[2]<<8) + a[3];
-}
-
-/*
-** Implementation of the ".info" command.
-**
-** Return 1 on error, 2 to exit, and 0 otherwise.
-*/
-static int shell_dbinfo_command(ShellState *p, int nArg, char **azArg){
-  static const struct { const char *zName; int ofst; } aField[] = {
-     { "file change counter:",  24  },
-     { "database page count:",  28  },
-     { "freelist page count:",  36  },
-     { "schema cookie:",        40  },
-     { "schema format:",        44  },
-     { "default cache size:",   48  },
-     { "autovacuum top root:",  52  },
-     { "incremental vacuum:",   64  },
-     { "text encoding:",        56  },
-     { "user version:",         60  },
-     { "application id:",       68  },
-     { "software version:",     96  },
-  };
-  static const struct { const char *zName; const char *zSql; } aQuery[] = {
-     { "number of tables:",
-       "SELECT count(*) FROM %s WHERE type='table'" },
-     { "number of indexes:",
-       "SELECT count(*) FROM %s WHERE type='index'" },
-     { "number of triggers:",
-       "SELECT count(*) FROM %s WHERE type='trigger'" },
-     { "number of views:",
-       "SELECT count(*) FROM %s WHERE type='view'" },
-     { "schema size:",
-       "SELECT total(length(sql)) FROM %s" },
-  };
-  sqlite3_file *pFile = 0;
-  int i;
-  char *zSchemaTab;
-  char *zDb = nArg>=2 ? azArg[1] : "main";
-  unsigned char aHdr[100];
-  open_db(p, 0);
-  if( p->db==0 ) return 1;
-  sqlite3_file_control(p->db, zDb, SQLITE_FCNTL_FILE_POINTER, &pFile);
-  if( pFile==0 || pFile->pMethods==0 || pFile->pMethods->xRead==0 ){
-    return 1;
-  }
-  i = pFile->pMethods->xRead(pFile, aHdr, 100, 0);
-  if( i!=SQLITE_OK ){
-    raw_printf(stderr, "unable to read database header\n");
-    return 1;
-  }
-  i = get2byteInt(aHdr+16);
-  if( i==1 ) i = 65536;
-  utf8_printf(p->out, "%-20s %d\n", "database page size:", i);
-  utf8_printf(p->out, "%-20s %d\n", "write format:", aHdr[18]);
-  utf8_printf(p->out, "%-20s %d\n", "read format:", aHdr[19]);
-  utf8_printf(p->out, "%-20s %d\n", "reserved bytes:", aHdr[20]);
-  for(i=0; i<ArraySize(aField); i++){
-    int ofst = aField[i].ofst;
-    unsigned int val = get4byteInt(aHdr + ofst);
-    utf8_printf(p->out, "%-20s %u", aField[i].zName, val);
-    switch( ofst ){
-      case 56: {
-        if( val==1 ) raw_printf(p->out, " (utf8)"); 
-        if( val==2 ) raw_printf(p->out, " (utf16le)"); 
-        if( val==3 ) raw_printf(p->out, " (utf16be)"); 
-      }
-    }
-    raw_printf(p->out, "\n");
-  }
-  if( zDb==0 ){
-    zSchemaTab = sqlite3_mprintf("main.sqlite_master");
-  }else if( strcmp(zDb,"temp")==0 ){
-    zSchemaTab = sqlite3_mprintf("%s", "sqlite_temp_master");
-  }else{
-    zSchemaTab = sqlite3_mprintf("\"%w\".sqlite_master", zDb);
-  }
-  for(i=0; i<ArraySize(aQuery); i++){
-    char *zSql = sqlite3_mprintf(aQuery[i].zSql, zSchemaTab);
-    int val = db_int(p, zSql);
-    sqlite3_free(zSql);
-    utf8_printf(p->out, "%-20s %d\n", aQuery[i].zName, val);
-  }
-  sqlite3_free(zSchemaTab);
-  return 0;
-}
-
-/*
-** Print the current sqlite3_errmsg() value to stderr and return 1.
-*/
-static int shellDatabaseError(sqlite3 *db){
-  const char *zErr = sqlite3_errmsg(db);
-  utf8_printf(stderr, "Error: %s\n", zErr);
-  return 1;
-}
-
-/*
-** Print an out-of-memory message to stderr and return 1.
-*/
-static int shellNomemError(void){
-  raw_printf(stderr, "Error: out of memory\n");
-  return 1;
-}
-
-/*
-** If an input line begins with "." then invoke this routine to
-** process that line.
-**
-** Return 1 on error, 2 to exit, and 0 otherwise.
-*/
-static int do_meta_command(char *zLine, ShellState *p){
-  int h = 1;
-  int nArg = 0;
-  int n, c;
-  int rc = 0;
-  char *azArg[50];
-
-  /* Parse the input line into tokens.
-  */
-  while( zLine[h] && nArg<ArraySize(azArg) ){
-    while( IsSpace(zLine[h]) ){ h++; }
-    if( zLine[h]==0 ) break;
-    if( zLine[h]=='\'' || zLine[h]=='"' ){
-      int delim = zLine[h++];
-      azArg[nArg++] = &zLine[h];
-      while( zLine[h] && zLine[h]!=delim ){ 
-        if( zLine[h]=='\\' && delim=='"' && zLine[h+1]!=0 ) h++;
-        h++; 
-      }
-      if( zLine[h]==delim ){
-        zLine[h++] = 0;
-      }
-      if( delim=='"' ) resolve_backslashes(azArg[nArg-1]);
-    }else{
-      azArg[nArg++] = &zLine[h];
-      while( zLine[h] && !IsSpace(zLine[h]) ){ h++; }
-      if( zLine[h] ) zLine[h++] = 0;
-      resolve_backslashes(azArg[nArg-1]);
-    }
-  }
-
-  /* Process the input line.
-  */
-  if( nArg==0 ) return 0; /* no tokens, no error */
-  n = strlen30(azArg[0]);
-  c = azArg[0][0];
-  if( (c=='b' && n>=3 && strncmp(azArg[0], "backup", n)==0)
-   || (c=='s' && n>=3 && strncmp(azArg[0], "save", n)==0)
-  ){
-    const char *zDestFile = 0;
-    const char *zDb = 0;
-    sqlite3 *pDest;
-    sqlite3_backup *pBackup;
-    int j;
-    for(j=1; j<nArg; j++){
-      const char *z = azArg[j];
-      if( z[0]=='-' ){
-        while( z[0]=='-' ) z++;
-        /* No options to process at this time */
-        {
-          utf8_printf(stderr, "unknown option: %s\n", azArg[j]);
-          return 1;
-        }
-      }else if( zDestFile==0 ){
-        zDestFile = azArg[j];
-      }else if( zDb==0 ){
-        zDb = zDestFile;
-        zDestFile = azArg[j];
-      }else{
-        raw_printf(stderr, "too many arguments to .backup\n");
-        return 1;
-      }
-    }
-    if( zDestFile==0 ){
-      raw_printf(stderr, "missing FILENAME argument on .backup\n");
-      return 1;
-    }
-    if( zDb==0 ) zDb = "main";
-    rc = sqlite3_open(zDestFile, &pDest);
-    if( rc!=SQLITE_OK ){
-      utf8_printf(stderr, "Error: cannot open \"%s\"\n", zDestFile);
-      sqlite3_close(pDest);
-      return 1;
-    }
-    open_db(p, 0);
-    pBackup = sqlite3_backup_init(pDest, "main", p->db, zDb);
-    if( pBackup==0 ){
-      utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
-      sqlite3_close(pDest);
-      return 1;
-    }
-    while(  (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK ){}
-    sqlite3_backup_finish(pBackup);
-    if( rc==SQLITE_DONE ){
-      rc = 0;
-    }else{
-      utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(pDest));
-      rc = 1;
-    }
-    sqlite3_close(pDest);
-  }else
-
-  if( c=='b' && n>=3 && strncmp(azArg[0], "bail", n)==0 ){
-    if( nArg==2 ){
-      bail_on_error = booleanValue(azArg[1]);
-    }else{
-      raw_printf(stderr, "Usage: .bail on|off\n");
-      rc = 1;
-    }
-  }else
-
-  if( c=='b' && n>=3 && strncmp(azArg[0], "binary", n)==0 ){
-    if( nArg==2 ){
-      if( booleanValue(azArg[1]) ){
-        setBinaryMode(p->out);
-      }else{
-        setTextMode(p->out);
-      }
-    }else{
-      raw_printf(stderr, "Usage: .binary on|off\n");
-      rc = 1;
-    }
-  }else
-
-  /* The undocumented ".breakpoint" command causes a call to the no-op
-  ** routine named test_breakpoint().
-  */
-  if( c=='b' && n>=3 && strncmp(azArg[0], "breakpoint", n)==0 ){
-    test_breakpoint();
-  }else
-
-  if( c=='c' && n>=3 && strncmp(azArg[0], "changes", n)==0 ){
-    if( nArg==2 ){
-      p->countChanges = booleanValue(azArg[1]);
-    }else{
-      raw_printf(stderr, "Usage: .changes on|off\n");
-      rc = 1;
-    }
-  }else
-
-  if( c=='c' && strncmp(azArg[0], "clone", n)==0 ){
-    if( nArg==2 ){
-      tryToClone(p, azArg[1]);
-    }else{
-      raw_printf(stderr, "Usage: .clone FILENAME\n");
-      rc = 1;
-    }
-  }else
-
-  if( c=='d' && n>1 && strncmp(azArg[0], "databases", n)==0 ){
-    ShellState data;
-    char *zErrMsg = 0;
-    open_db(p, 0);
-    memcpy(&data, p, sizeof(data));
-    data.showHeader = 1;
-    data.mode = MODE_Column;
-    data.colWidth[0] = 3;
-    data.colWidth[1] = 15;
-    data.colWidth[2] = 58;
-    data.cnt = 0;
-    sqlite3_exec(p->db, "PRAGMA database_list; ", callback, &data, &zErrMsg);
-    if( zErrMsg ){
-      utf8_printf(stderr,"Error: %s\n", zErrMsg);
-      sqlite3_free(zErrMsg);
-      rc = 1;
-    }
-  }else
-
-  if( c=='d' && strncmp(azArg[0], "dbinfo", n)==0 ){
-    rc = shell_dbinfo_command(p, nArg, azArg);
-  }else
-
-  if( c=='d' && strncmp(azArg[0], "dump", n)==0 ){
-    open_db(p, 0);
-    /* When playing back a "dump", the content might appear in an order
-    ** which causes immediate foreign key constraints to be violated.
-    ** So disable foreign-key constraint enforcement to prevent problems. */
-    if( nArg!=1 && nArg!=2 ){
-      raw_printf(stderr, "Usage: .dump ?LIKE-PATTERN?\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    raw_printf(p->out, "PRAGMA foreign_keys=OFF;\n");
-    raw_printf(p->out, "BEGIN TRANSACTION;\n");
-    p->writableSchema = 0;
-    sqlite3_exec(p->db, "SAVEPOINT dump; PRAGMA writable_schema=ON", 0, 0, 0);
-    p->nErr = 0;
-    if( nArg==1 ){
-      run_schema_dump_query(p, 
-        "SELECT name, type, sql FROM sqlite_master "
-        "WHERE sql NOT NULL AND type=='table' AND name!='sqlite_sequence'"
-      );
-      run_schema_dump_query(p, 
-        "SELECT name, type, sql FROM sqlite_master "
-        "WHERE name=='sqlite_sequence'"
-      );
-      run_table_dump_query(p,
-        "SELECT sql FROM sqlite_master "
-        "WHERE sql NOT NULL AND type IN ('index','trigger','view')", 0
-      );
-    }else{
-      int i;
-      for(i=1; i<nArg; i++){
-        zShellStatic = azArg[i];
-        run_schema_dump_query(p,
-          "SELECT name, type, sql FROM sqlite_master "
-          "WHERE tbl_name LIKE shellstatic() AND type=='table'"
-          "  AND sql NOT NULL");
-        run_table_dump_query(p,
-          "SELECT sql FROM sqlite_master "
-          "WHERE sql NOT NULL"
-          "  AND type IN ('index','trigger','view')"
-          "  AND tbl_name LIKE shellstatic()", 0
-        );
-        zShellStatic = 0;
-      }
-    }
-    if( p->writableSchema ){
-      raw_printf(p->out, "PRAGMA writable_schema=OFF;\n");
-      p->writableSchema = 0;
-    }
-    sqlite3_exec(p->db, "PRAGMA writable_schema=OFF;", 0, 0, 0);
-    sqlite3_exec(p->db, "RELEASE dump;", 0, 0, 0);
-    raw_printf(p->out, p->nErr ? "ROLLBACK; -- due to errors\n" : "COMMIT;\n");
-  }else
-
-  if( c=='e' && strncmp(azArg[0], "echo", n)==0 ){
-    if( nArg==2 ){
-      p->echoOn = booleanValue(azArg[1]);
-    }else{
-      raw_printf(stderr, "Usage: .echo on|off\n");
-      rc = 1;
-    }
-  }else
-
-  if( c=='e' && strncmp(azArg[0], "eqp", n)==0 ){
-    if( nArg==2 ){
-      p->autoEQP = booleanValue(azArg[1]);
-    }else{
-      raw_printf(stderr, "Usage: .eqp on|off\n");
-      rc = 1;
-    }   
-  }else
-
-  if( c=='e' && strncmp(azArg[0], "exit", n)==0 ){
-    if( nArg>1 && (rc = (int)integerValue(azArg[1]))!=0 ) exit(rc);
-    rc = 2;
-  }else
-
-  if( c=='e' && strncmp(azArg[0], "explain", n)==0 ){
-    int val = nArg>=2 ? booleanValue(azArg[1]) : 1;
-    if(val == 1) {
-      if(!p->normalMode.valid) {
-        p->normalMode.valid = 1;
-        p->normalMode.mode = p->mode;
-        p->normalMode.showHeader = p->showHeader;
-        memcpy(p->normalMode.colWidth,p->colWidth,sizeof(p->colWidth));
-      }
-      /* We could put this code under the !p->explainValid
-      ** condition so that it does not execute if we are already in
-      ** explain mode. However, always executing it allows us an easy
-      ** was to reset to explain mode in case the user previously
-      ** did an .explain followed by a .width, .mode or .header
-      ** command.
-      */
-      p->mode = MODE_Explain;
-      p->showHeader = 1;
-      memset(p->colWidth,0,sizeof(p->colWidth));
-      p->colWidth[0] = 4;                  /* addr */
-      p->colWidth[1] = 13;                 /* opcode */
-      p->colWidth[2] = 4;                  /* P1 */
-      p->colWidth[3] = 4;                  /* P2 */
-      p->colWidth[4] = 4;                  /* P3 */
-      p->colWidth[5] = 13;                 /* P4 */
-      p->colWidth[6] = 2;                  /* P5 */
-      p->colWidth[7] = 13;                  /* Comment */
-    }else if (p->normalMode.valid) {
-      p->normalMode.valid = 0;
-      p->mode = p->normalMode.mode;
-      p->showHeader = p->normalMode.showHeader;
-      memcpy(p->colWidth,p->normalMode.colWidth,sizeof(p->colWidth));
-    }
-  }else
-
-  if( c=='f' && strncmp(azArg[0], "fullschema", n)==0 ){
-    ShellState data;
-    char *zErrMsg = 0;
-    int doStats = 0;
-    if( nArg!=1 ){
-      raw_printf(stderr, "Usage: .fullschema\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    open_db(p, 0);
-    memcpy(&data, p, sizeof(data));
-    data.showHeader = 0;
-    data.mode = MODE_Semi;
-    rc = sqlite3_exec(p->db,
-       "SELECT sql FROM"
-       "  (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
-       "     FROM sqlite_master UNION ALL"
-       "   SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
-       "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
-       "ORDER BY rowid",
-       callback, &data, &zErrMsg
-    );
-    if( rc==SQLITE_OK ){
-      sqlite3_stmt *pStmt;
-      rc = sqlite3_prepare_v2(p->db,
-               "SELECT rowid FROM sqlite_master"
-               " WHERE name GLOB 'sqlite_stat[134]'",
-               -1, &pStmt, 0);
-      doStats = sqlite3_step(pStmt)==SQLITE_ROW;
-      sqlite3_finalize(pStmt);
-    }
-    if( doStats==0 ){
-      raw_printf(p->out, "/* No STAT tables available */\n");
-    }else{
-      raw_printf(p->out, "ANALYZE sqlite_master;\n");
-      sqlite3_exec(p->db, "SELECT 'ANALYZE sqlite_master'",
-                   callback, &data, &zErrMsg);
-      data.mode = MODE_Insert;
-      data.zDestTable = "sqlite_stat1";
-      shell_exec(p->db, "SELECT * FROM sqlite_stat1",
-                 shell_callback, &data,&zErrMsg);
-      data.zDestTable = "sqlite_stat3";
-      shell_exec(p->db, "SELECT * FROM sqlite_stat3",
-                 shell_callback, &data,&zErrMsg);
-      data.zDestTable = "sqlite_stat4";
-      shell_exec(p->db, "SELECT * FROM sqlite_stat4",
-                 shell_callback, &data, &zErrMsg);
-      raw_printf(p->out, "ANALYZE sqlite_master;\n");
-    }
-  }else
-
-  if( c=='h' && strncmp(azArg[0], "headers", n)==0 ){
-    if( nArg==2 ){
-      p->showHeader = booleanValue(azArg[1]);
-    }else{
-      raw_printf(stderr, "Usage: .headers on|off\n");
-      rc = 1;
-    }
-  }else
-
-  if( c=='h' && strncmp(azArg[0], "help", n)==0 ){
-    utf8_printf(p->out, "%s", zHelp);
-  }else
-
-  if( c=='i' && strncmp(azArg[0], "import", n)==0 ){
-    char *zTable;               /* Insert data into this table */
-    char *zFile;                /* Name of file to extra content from */
-    sqlite3_stmt *pStmt = NULL; /* A statement */
-    int nCol;                   /* Number of columns in the table */
-    int nByte;                  /* Number of bytes in an SQL string */
-    int i, j;                   /* Loop counters */
-    int needCommit;             /* True to COMMIT or ROLLBACK at end */
-    int nSep;                   /* Number of bytes in p->colSeparator[] */
-    char *zSql;                 /* An SQL statement */
-    ImportCtx sCtx;             /* Reader context */
-    char *(SQLITE_CDECL *xRead)(ImportCtx*); /* Func to read one value */
-    int (SQLITE_CDECL *xCloser)(FILE*);      /* Func to close file */
-
-    if( nArg!=3 ){
-      raw_printf(stderr, "Usage: .import FILE TABLE\n");
-      goto meta_command_exit;
-    }
-    zFile = azArg[1];
-    zTable = azArg[2];
-    seenInterrupt = 0;
-    memset(&sCtx, 0, sizeof(sCtx));
-    open_db(p, 0);
-    nSep = strlen30(p->colSeparator);
-    if( nSep==0 ){
-      raw_printf(stderr,
-                 "Error: non-null column separator required for import\n");
-      return 1;
-    }
-    if( nSep>1 ){
-      raw_printf(stderr, "Error: multi-character column separators not allowed"
-                      " for import\n");
-      return 1;
-    }
-    nSep = strlen30(p->rowSeparator);
-    if( nSep==0 ){
-      raw_printf(stderr, "Error: non-null row separator required for import\n");
-      return 1;
-    }
-    if( nSep==2 && p->mode==MODE_Csv && strcmp(p->rowSeparator, SEP_CrLf)==0 ){
-      /* When importing CSV (only), if the row separator is set to the
-      ** default output row separator, change it to the default input
-      ** row separator.  This avoids having to maintain different input
-      ** and output row separators. */
-      sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Row);
-      nSep = strlen30(p->rowSeparator);
-    }
-    if( nSep>1 ){
-      raw_printf(stderr, "Error: multi-character row separators not allowed"
-                      " for import\n");
-      return 1;
-    }
-    sCtx.zFile = zFile;
-    sCtx.nLine = 1;
-    if( sCtx.zFile[0]=='|' ){
-#ifdef SQLITE_OMIT_POPEN
-      raw_printf(stderr, "Error: pipes are not supported in this OS\n");
-      return 1;
-#else
-      sCtx.in = popen(sCtx.zFile+1, "r");
-      sCtx.zFile = "<pipe>";
-      xCloser = pclose;
-#endif
-    }else{
-      sCtx.in = fopen(sCtx.zFile, "rb");
-      xCloser = fclose;
-    }
-    if( p->mode==MODE_Ascii ){
-      xRead = ascii_read_one_field;
-    }else{
-      xRead = csv_read_one_field;
-    }
-    if( sCtx.in==0 ){
-      utf8_printf(stderr, "Error: cannot open \"%s\"\n", zFile);
-      return 1;
-    }
-    sCtx.cColSep = p->colSeparator[0];
-    sCtx.cRowSep = p->rowSeparator[0];
-    zSql = sqlite3_mprintf("SELECT * FROM %s", zTable);
-    if( zSql==0 ){
-      raw_printf(stderr, "Error: out of memory\n");
-      xCloser(sCtx.in);
-      return 1;
-    }
-    nByte = strlen30(zSql);
-    rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
-    import_append_char(&sCtx, 0);    /* To ensure sCtx.z is allocated */
-    if( rc && sqlite3_strglob("no such table: *", sqlite3_errmsg(p->db))==0 ){
-      char *zCreate = sqlite3_mprintf("CREATE TABLE %s", zTable);
-      char cSep = '(';
-      while( xRead(&sCtx) ){
-        zCreate = sqlite3_mprintf("%z%c\n  \"%s\" TEXT", zCreate, cSep, sCtx.z);
-        cSep = ',';
-        if( sCtx.cTerm!=sCtx.cColSep ) break;
-      }
-      if( cSep=='(' ){
-        sqlite3_free(zCreate);
-        sqlite3_free(sCtx.z);
-        xCloser(sCtx.in);
-        utf8_printf(stderr,"%s: empty file\n", sCtx.zFile);
-        return 1;
-      }
-      zCreate = sqlite3_mprintf("%z\n)", zCreate);
-      rc = sqlite3_exec(p->db, zCreate, 0, 0, 0);
-      sqlite3_free(zCreate);
-      if( rc ){
-        utf8_printf(stderr, "CREATE TABLE %s(...) failed: %s\n", zTable,
-                sqlite3_errmsg(p->db));
-        sqlite3_free(sCtx.z);
-        xCloser(sCtx.in);
-        return 1;
-      }
-      rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
-    }
-    sqlite3_free(zSql);
-    if( rc ){
-      if (pStmt) sqlite3_finalize(pStmt);
-      utf8_printf(stderr,"Error: %s\n", sqlite3_errmsg(p->db));
-      xCloser(sCtx.in);
-      return 1;
-    }
-    nCol = sqlite3_column_count(pStmt);
-    sqlite3_finalize(pStmt);
-    pStmt = 0;
-    if( nCol==0 ) return 0; /* no columns, no error */
-    zSql = sqlite3_malloc64( nByte*2 + 20 + nCol*2 );
-    if( zSql==0 ){
-      raw_printf(stderr, "Error: out of memory\n");
-      xCloser(sCtx.in);
-      return 1;
-    }
-    sqlite3_snprintf(nByte+20, zSql, "INSERT INTO \"%w\" VALUES(?", zTable);
-    j = strlen30(zSql);
-    for(i=1; i<nCol; i++){
-      zSql[j++] = ',';
-      zSql[j++] = '?';
-    }
-    zSql[j++] = ')';
-    zSql[j] = 0;
-    rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
-    sqlite3_free(zSql);
-    if( rc ){
-      utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
-      if (pStmt) sqlite3_finalize(pStmt);
-      xCloser(sCtx.in);
-      return 1;
-    }
-    needCommit = sqlite3_get_autocommit(p->db);
-    if( needCommit ) sqlite3_exec(p->db, "BEGIN", 0, 0, 0);
-    do{
-      int startLine = sCtx.nLine;
-      for(i=0; i<nCol; i++){
-        char *z = xRead(&sCtx);
-        /*
-        ** Did we reach end-of-file before finding any columns?
-        ** If so, stop instead of NULL filling the remaining columns.
-        */
-        if( z==0 && i==0 ) break;
-        /*
-        ** Did we reach end-of-file OR end-of-line before finding any
-        ** columns in ASCII mode?  If so, stop instead of NULL filling
-        ** the remaining columns.
-        */
-        if( p->mode==MODE_Ascii && (z==0 || z[0]==0) && i==0 ) break;
-        sqlite3_bind_text(pStmt, i+1, z, -1, SQLITE_TRANSIENT);
-        if( i<nCol-1 && sCtx.cTerm!=sCtx.cColSep ){
-          utf8_printf(stderr, "%s:%d: expected %d columns but found %d - "
-                          "filling the rest with NULL\n",
-                          sCtx.zFile, startLine, nCol, i+1);
-          i += 2;
-          while( i<=nCol ){ sqlite3_bind_null(pStmt, i); i++; }
-        }
-      }
-      if( sCtx.cTerm==sCtx.cColSep ){
-        do{
-          xRead(&sCtx);
-          i++;
-        }while( sCtx.cTerm==sCtx.cColSep );
-        utf8_printf(stderr, "%s:%d: expected %d columns but found %d - "
-                        "extras ignored\n",
-                        sCtx.zFile, startLine, nCol, i);
-      }
-      if( i>=nCol ){
-        sqlite3_step(pStmt);
-        rc = sqlite3_reset(pStmt);
-        if( rc!=SQLITE_OK ){
-          utf8_printf(stderr, "%s:%d: INSERT failed: %s\n", sCtx.zFile,
-                      startLine, sqlite3_errmsg(p->db));
-        }
-      }
-    }while( sCtx.cTerm!=EOF );
-
-    xCloser(sCtx.in);
-    sqlite3_free(sCtx.z);
-    sqlite3_finalize(pStmt);
-    if( needCommit ) sqlite3_exec(p->db, "COMMIT", 0, 0, 0);
-  }else
-
-  if( c=='i' && (strncmp(azArg[0], "indices", n)==0
-                 || strncmp(azArg[0], "indexes", n)==0) ){
-    ShellState data;
-    char *zErrMsg = 0;
-    open_db(p, 0);
-    memcpy(&data, p, sizeof(data));
-    data.showHeader = 0;
-    data.mode = MODE_List;
-    if( nArg==1 ){
-      rc = sqlite3_exec(p->db,
-        "SELECT name FROM sqlite_master "
-        "WHERE type='index' AND name NOT LIKE 'sqlite_%' "
-        "UNION ALL "
-        "SELECT name FROM sqlite_temp_master "
-        "WHERE type='index' "
-        "ORDER BY 1",
-        callback, &data, &zErrMsg
-      );
-    }else if( nArg==2 ){
-      zShellStatic = azArg[1];
-      rc = sqlite3_exec(p->db,
-        "SELECT name FROM sqlite_master "
-        "WHERE type='index' AND tbl_name LIKE shellstatic() "
-        "UNION ALL "
-        "SELECT name FROM sqlite_temp_master "
-        "WHERE type='index' AND tbl_name LIKE shellstatic() "
-        "ORDER BY 1",
-        callback, &data, &zErrMsg
-      );
-      zShellStatic = 0;
-    }else{
-      raw_printf(stderr, "Usage: .indexes ?LIKE-PATTERN?\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    if( zErrMsg ){
-      utf8_printf(stderr,"Error: %s\n", zErrMsg);
-      sqlite3_free(zErrMsg);
-      rc = 1;
-    }else if( rc != SQLITE_OK ){
-      raw_printf(stderr,
-                 "Error: querying sqlite_master and sqlite_temp_master\n");
-      rc = 1;
-    }
-  }else
-
-#ifdef SQLITE_ENABLE_IOTRACE
-  if( c=='i' && strncmp(azArg[0], "iotrace", n)==0 ){
-    SQLITE_API extern void (SQLITE_CDECL *sqlite3IoTrace)(const char*, ...);
-    if( iotrace && iotrace!=stdout ) fclose(iotrace);
-    iotrace = 0;
-    if( nArg<2 ){
-      sqlite3IoTrace = 0;
-    }else if( strcmp(azArg[1], "-")==0 ){
-      sqlite3IoTrace = iotracePrintf;
-      iotrace = stdout;
-    }else{
-      iotrace = fopen(azArg[1], "w");
-      if( iotrace==0 ){
-        utf8_printf(stderr, "Error: cannot open \"%s\"\n", azArg[1]);
-        sqlite3IoTrace = 0;
-        rc = 1;
-      }else{
-        sqlite3IoTrace = iotracePrintf;
-      }
-    }
-  }else
-#endif
-  if( c=='l' && n>=5 && strncmp(azArg[0], "limits", n)==0 ){
-    static const struct {
-       const char *zLimitName;   /* Name of a limit */
-       int limitCode;            /* Integer code for that limit */
-    } aLimit[] = {
-      { "length",                SQLITE_LIMIT_LENGTH                    },
-      { "sql_length",            SQLITE_LIMIT_SQL_LENGTH                },
-      { "column",                SQLITE_LIMIT_COLUMN                    },
-      { "expr_depth",            SQLITE_LIMIT_EXPR_DEPTH                },
-      { "compound_select",       SQLITE_LIMIT_COMPOUND_SELECT           },
-      { "vdbe_op",               SQLITE_LIMIT_VDBE_OP                   },
-      { "function_arg",          SQLITE_LIMIT_FUNCTION_ARG              },
-      { "attached",              SQLITE_LIMIT_ATTACHED                  },
-      { "like_pattern_length",   SQLITE_LIMIT_LIKE_PATTERN_LENGTH       },
-      { "variable_number",       SQLITE_LIMIT_VARIABLE_NUMBER           },
-      { "trigger_depth",         SQLITE_LIMIT_TRIGGER_DEPTH             },
-      { "worker_threads",        SQLITE_LIMIT_WORKER_THREADS            },
-    };
-    int i, n2;
-    open_db(p, 0);
-    if( nArg==1 ){
-      for(i=0; i<ArraySize(aLimit); i++){
-        printf("%20s %d\n", aLimit[i].zLimitName, 
-               sqlite3_limit(p->db, aLimit[i].limitCode, -1));
-      }
-    }else if( nArg>3 ){
-      raw_printf(stderr, "Usage: .limit NAME ?NEW-VALUE?\n");
-      rc = 1;
-      goto meta_command_exit;
-    }else{
-      int iLimit = -1;
-      n2 = strlen30(azArg[1]);
-      for(i=0; i<ArraySize(aLimit); i++){
-        if( sqlite3_strnicmp(aLimit[i].zLimitName, azArg[1], n2)==0 ){
-          if( iLimit<0 ){
-            iLimit = i;
-          }else{
-            utf8_printf(stderr, "ambiguous limit: \"%s\"\n", azArg[1]);
-            rc = 1;
-            goto meta_command_exit;
-          }
-        }
-      }
-      if( iLimit<0 ){
-        utf8_printf(stderr, "unknown limit: \"%s\"\n"
-                        "enter \".limits\" with no arguments for a list.\n",
-                         azArg[1]);
-        rc = 1;
-        goto meta_command_exit;
-      }
-      if( nArg==3 ){
-        sqlite3_limit(p->db, aLimit[iLimit].limitCode,
-                      (int)integerValue(azArg[2]));
-      }
-      printf("%20s %d\n", aLimit[iLimit].zLimitName,
-             sqlite3_limit(p->db, aLimit[iLimit].limitCode, -1));
-    }
-  }else
-
-#ifndef SQLITE_OMIT_LOAD_EXTENSION
-  if( c=='l' && strncmp(azArg[0], "load", n)==0 ){
-    const char *zFile, *zProc;
-    char *zErrMsg = 0;
-    if( nArg<2 ){
-      raw_printf(stderr, "Usage: .load FILE ?ENTRYPOINT?\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    zFile = azArg[1];
-    zProc = nArg>=3 ? azArg[2] : 0;
-    open_db(p, 0);
-    rc = sqlite3_load_extension(p->db, zFile, zProc, &zErrMsg);
-    if( rc!=SQLITE_OK ){
-      utf8_printf(stderr, "Error: %s\n", zErrMsg);
-      sqlite3_free(zErrMsg);
-      rc = 1;
-    }
-  }else
-#endif
-
-  if( c=='l' && strncmp(azArg[0], "log", n)==0 ){
-    if( nArg!=2 ){
-      raw_printf(stderr, "Usage: .log FILENAME\n");
-      rc = 1;
-    }else{
-      const char *zFile = azArg[1];
-      output_file_close(p->pLog);
-      p->pLog = output_file_open(zFile);
-    }
-  }else
-
-  if( c=='m' && strncmp(azArg[0], "mode", n)==0 ){
-    const char *zMode = nArg>=2 ? azArg[1] : "";
-    int n2 = (int)strlen(zMode);
-    int c2 = zMode[0];
-    if( c2=='l' && n2>2 && strncmp(azArg[1],"lines",n2)==0 ){
-      p->mode = MODE_Line;
-    }else if( c2=='c' && strncmp(azArg[1],"columns",n2)==0 ){
-      p->mode = MODE_Column;
-    }else if( c2=='l' && n2>2 && strncmp(azArg[1],"list",n2)==0 ){
-      p->mode = MODE_List;
-    }else if( c2=='h' && strncmp(azArg[1],"html",n2)==0 ){
-      p->mode = MODE_Html;
-    }else if( c2=='t' && strncmp(azArg[1],"tcl",n2)==0 ){
-      p->mode = MODE_Tcl;
-      sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Space);
-    }else if( c2=='c' && strncmp(azArg[1],"csv",n2)==0 ){
-      p->mode = MODE_Csv;
-      sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Comma);
-      sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_CrLf);
-    }else if( c2=='t' && strncmp(azArg[1],"tabs",n2)==0 ){
-      p->mode = MODE_List;
-      sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Tab);
-    }else if( c2=='i' && strncmp(azArg[1],"insert",n2)==0 ){
-      p->mode = MODE_Insert;
-      set_table_name(p, nArg>=3 ? azArg[2] : "table");
-    }else if( c2=='a' && strncmp(azArg[1],"ascii",n2)==0 ){
-      p->mode = MODE_Ascii;
-      sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator, SEP_Unit);
-      sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator, SEP_Record);
-    }else {
-      raw_printf(stderr, "Error: mode should be one of: "
-         "ascii column csv html insert line list tabs tcl\n");
-      rc = 1;
-    }
-  }else
-
-  if( c=='n' && strncmp(azArg[0], "nullvalue", n)==0 ){
-    if( nArg==2 ){
-      sqlite3_snprintf(sizeof(p->nullValue), p->nullValue,
-                       "%.*s", (int)ArraySize(p->nullValue)-1, azArg[1]);
-    }else{
-      raw_printf(stderr, "Usage: .nullvalue STRING\n");
-      rc = 1;
-    }
-  }else
-
-  if( c=='o' && strncmp(azArg[0], "open", n)==0 && n>=2 ){
-    sqlite3 *savedDb = p->db;
-    const char *zSavedFilename = p->zDbFilename;
-    char *zNewFilename = 0;
-    p->db = 0;
-    if( nArg>=2 ) zNewFilename = sqlite3_mprintf("%s", azArg[1]);
-    p->zDbFilename = zNewFilename;
-    open_db(p, 1);
-    if( p->db!=0 ){
-      sqlite3_close(savedDb);
-      sqlite3_free(p->zFreeOnClose);
-      p->zFreeOnClose = zNewFilename;
-    }else{
-      sqlite3_free(zNewFilename);
-      p->db = savedDb;
-      p->zDbFilename = zSavedFilename;
-    }
-  }else
-
-  if( c=='o'
-   && (strncmp(azArg[0], "output", n)==0 || strncmp(azArg[0], "once", n)==0)
-  ){
-    const char *zFile = nArg>=2 ? azArg[1] : "stdout";
-    if( nArg>2 ){
-      utf8_printf(stderr, "Usage: .%s FILE\n", azArg[0]);
-      rc = 1;
-      goto meta_command_exit;
-    }
-    if( n>1 && strncmp(azArg[0], "once", n)==0 ){
-      if( nArg<2 ){
-        raw_printf(stderr, "Usage: .once FILE\n");
-        rc = 1;
-        goto meta_command_exit;
-      }
-      p->outCount = 2;
-    }else{
-      p->outCount = 0;
-    }
-    output_reset(p);
-    if( zFile[0]=='|' ){
-#ifdef SQLITE_OMIT_POPEN
-      raw_printf(stderr, "Error: pipes are not supported in this OS\n");
-      rc = 1;
-      p->out = stdout;
-#else
-      p->out = popen(zFile + 1, "w");
-      if( p->out==0 ){
-        utf8_printf(stderr,"Error: cannot open pipe \"%s\"\n", zFile + 1);
-        p->out = stdout;
-        rc = 1;
-      }else{
-        sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
-      }
-#endif
-    }else{
-      p->out = output_file_open(zFile);
-      if( p->out==0 ){
-        if( strcmp(zFile,"off")!=0 ){
-          utf8_printf(stderr,"Error: cannot write to \"%s\"\n", zFile);
-        }
-        p->out = stdout;
-        rc = 1;
-      } else {
-        sqlite3_snprintf(sizeof(p->outfile), p->outfile, "%s", zFile);
-      }
-    }
-  }else
-
-  if( c=='p' && n>=3 && strncmp(azArg[0], "print", n)==0 ){
-    int i;
-    for(i=1; i<nArg; i++){
-      if( i>1 ) raw_printf(p->out, " ");
-      utf8_printf(p->out, "%s", azArg[i]);
-    }
-    raw_printf(p->out, "\n");
-  }else
-
-  if( c=='p' && strncmp(azArg[0], "prompt", n)==0 ){
-    if( nArg >= 2) {
-      strncpy(mainPrompt,azArg[1],(int)ArraySize(mainPrompt)-1);
-    }
-    if( nArg >= 3) {
-      strncpy(continuePrompt,azArg[2],(int)ArraySize(continuePrompt)-1);
-    }
-  }else
-
-  if( c=='q' && strncmp(azArg[0], "quit", n)==0 ){
-    rc = 2;
-  }else
-
-  if( c=='r' && n>=3 && strncmp(azArg[0], "read", n)==0 ){
-    FILE *alt;
-    if( nArg!=2 ){
-      raw_printf(stderr, "Usage: .read FILE\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    alt = fopen(azArg[1], "rb");
-    if( alt==0 ){
-      utf8_printf(stderr,"Error: cannot open \"%s\"\n", azArg[1]);
-      rc = 1;
-    }else{
-      rc = process_input(p, alt);
-      fclose(alt);
-    }
-  }else
-
-  if( c=='r' && n>=3 && strncmp(azArg[0], "restore", n)==0 ){
-    const char *zSrcFile;
-    const char *zDb;
-    sqlite3 *pSrc;
-    sqlite3_backup *pBackup;
-    int nTimeout = 0;
-
-    if( nArg==2 ){
-      zSrcFile = azArg[1];
-      zDb = "main";
-    }else if( nArg==3 ){
-      zSrcFile = azArg[2];
-      zDb = azArg[1];
-    }else{
-      raw_printf(stderr, "Usage: .restore ?DB? FILE\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    rc = sqlite3_open(zSrcFile, &pSrc);
-    if( rc!=SQLITE_OK ){
-      utf8_printf(stderr, "Error: cannot open \"%s\"\n", zSrcFile);
-      sqlite3_close(pSrc);
-      return 1;
-    }
-    open_db(p, 0);
-    pBackup = sqlite3_backup_init(p->db, zDb, pSrc, "main");
-    if( pBackup==0 ){
-      utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
-      sqlite3_close(pSrc);
-      return 1;
-    }
-    while( (rc = sqlite3_backup_step(pBackup,100))==SQLITE_OK
-          || rc==SQLITE_BUSY  ){
-      if( rc==SQLITE_BUSY ){
-        if( nTimeout++ >= 3 ) break;
-        sqlite3_sleep(100);
-      }
-    }
-    sqlite3_backup_finish(pBackup);
-    if( rc==SQLITE_DONE ){
-      rc = 0;
-    }else if( rc==SQLITE_BUSY || rc==SQLITE_LOCKED ){
-      raw_printf(stderr, "Error: source database is busy\n");
-      rc = 1;
-    }else{
-      utf8_printf(stderr, "Error: %s\n", sqlite3_errmsg(p->db));
-      rc = 1;
-    }
-    sqlite3_close(pSrc);
-  }else
-
-
-  if( c=='s' && strncmp(azArg[0], "scanstats", n)==0 ){
-    if( nArg==2 ){
-      p->scanstatsOn = booleanValue(azArg[1]);
-#ifndef SQLITE_ENABLE_STMT_SCANSTATUS
-      raw_printf(stderr, "Warning: .scanstats not available in this build.\n");
-#endif
-    }else{
-      raw_printf(stderr, "Usage: .scanstats on|off\n");
-      rc = 1;
-    }
-  }else
-
-  if( c=='s' && strncmp(azArg[0], "schema", n)==0 ){
-    ShellState data;
-    char *zErrMsg = 0;
-    open_db(p, 0);
-    memcpy(&data, p, sizeof(data));
-    data.showHeader = 0;
-    data.mode = MODE_Semi;
-    if( nArg==2 ){
-      int i;
-      for(i=0; azArg[1][i]; i++) azArg[1][i] = ToLower(azArg[1][i]);
-      if( strcmp(azArg[1],"sqlite_master")==0 ){
-        char *new_argv[2], *new_colv[2];
-        new_argv[0] = "CREATE TABLE sqlite_master (\n"
-                      "  type text,\n"
-                      "  name text,\n"
-                      "  tbl_name text,\n"
-                      "  rootpage integer,\n"
-                      "  sql text\n"
-                      ")";
-        new_argv[1] = 0;
-        new_colv[0] = "sql";
-        new_colv[1] = 0;
-        callback(&data, 1, new_argv, new_colv);
-        rc = SQLITE_OK;
-      }else if( strcmp(azArg[1],"sqlite_temp_master")==0 ){
-        char *new_argv[2], *new_colv[2];
-        new_argv[0] = "CREATE TEMP TABLE sqlite_temp_master (\n"
-                      "  type text,\n"
-                      "  name text,\n"
-                      "  tbl_name text,\n"
-                      "  rootpage integer,\n"
-                      "  sql text\n"
-                      ")";
-        new_argv[1] = 0;
-        new_colv[0] = "sql";
-        new_colv[1] = 0;
-        callback(&data, 1, new_argv, new_colv);
-        rc = SQLITE_OK;
-      }else{
-        zShellStatic = azArg[1];
-        rc = sqlite3_exec(p->db,
-          "SELECT sql FROM "
-          "  (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
-          "     FROM sqlite_master UNION ALL"
-          "   SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
-          "WHERE lower(tbl_name) LIKE shellstatic()"
-          "  AND type!='meta' AND sql NOTNULL "
-          "ORDER BY rowid",
-          callback, &data, &zErrMsg);
-        zShellStatic = 0;
-      }
-    }else if( nArg==1 ){
-      rc = sqlite3_exec(p->db,
-         "SELECT sql FROM "
-         "  (SELECT sql sql, type type, tbl_name tbl_name, name name, rowid x"
-         "     FROM sqlite_master UNION ALL"
-         "   SELECT sql, type, tbl_name, name, rowid FROM sqlite_temp_master) "
-         "WHERE type!='meta' AND sql NOTNULL AND name NOT LIKE 'sqlite_%' "
-         "ORDER BY rowid",
-         callback, &data, &zErrMsg
-      );
-    }else{
-      raw_printf(stderr, "Usage: .schema ?LIKE-PATTERN?\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    if( zErrMsg ){
-      utf8_printf(stderr,"Error: %s\n", zErrMsg);
-      sqlite3_free(zErrMsg);
-      rc = 1;
-    }else if( rc != SQLITE_OK ){
-      raw_printf(stderr,"Error: querying schema information\n");
-      rc = 1;
-    }else{
-      rc = 0;
-    }
-  }else
-
-
-#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_SELECTTRACE)
-  if( c=='s' && n==11 && strncmp(azArg[0], "selecttrace", n)==0 ){
-    extern int sqlite3SelectTrace;
-    sqlite3SelectTrace = integerValue(azArg[1]);
-  }else
-#endif
-
-
-#ifdef SQLITE_DEBUG
-  /* Undocumented commands for internal testing.  Subject to change
-  ** without notice. */
-  if( c=='s' && n>=10 && strncmp(azArg[0], "selftest-", 9)==0 ){
-    if( strncmp(azArg[0]+9, "boolean", n-9)==0 ){
-      int i, v;
-      for(i=1; i<nArg; i++){
-        v = booleanValue(azArg[i]);
-        utf8_printf(p->out, "%s: %d 0x%x\n", azArg[i], v, v);
-      }
-    }
-    if( strncmp(azArg[0]+9, "integer", n-9)==0 ){
-      int i; sqlite3_int64 v;
-      for(i=1; i<nArg; i++){
-        char zBuf[200];
-        v = integerValue(azArg[i]);
-        sqlite3_snprintf(sizeof(zBuf),zBuf,"%s: %lld 0x%llx\n", azArg[i],v,v);
-        utf8_printf(p->out, "%s", zBuf);
-      }
-    }
-  }else
-#endif
-
-  if( c=='s' && strncmp(azArg[0], "separator", n)==0 ){
-    if( nArg<2 || nArg>3 ){
-      raw_printf(stderr, "Usage: .separator COL ?ROW?\n");
-      rc = 1;
-    }
-    if( nArg>=2 ){
-      sqlite3_snprintf(sizeof(p->colSeparator), p->colSeparator,
-                       "%.*s", (int)ArraySize(p->colSeparator)-1, azArg[1]);
-    }
-    if( nArg>=3 ){
-      sqlite3_snprintf(sizeof(p->rowSeparator), p->rowSeparator,
-                       "%.*s", (int)ArraySize(p->rowSeparator)-1, azArg[2]);
-    }
-  }else
-
-  if( c=='s'
-   && (strncmp(azArg[0], "shell", n)==0 || strncmp(azArg[0],"system",n)==0)
-  ){
-    char *zCmd;
-    int i, x;
-    if( nArg<2 ){
-      raw_printf(stderr, "Usage: .system COMMAND\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    zCmd = sqlite3_mprintf(strchr(azArg[1],' ')==0?"%s":"\"%s\"", azArg[1]);
-    for(i=2; i<nArg; i++){
-      zCmd = sqlite3_mprintf(strchr(azArg[i],' ')==0?"%z %s":"%z \"%s\"",
-                             zCmd, azArg[i]);
-    }
-    x = system(zCmd);
-    sqlite3_free(zCmd);
-    if( x ) raw_printf(stderr, "System command returns %d\n", x);
-  }else
-
-  if( c=='s' && strncmp(azArg[0], "show", n)==0 ){
-    int i;
-    if( nArg!=1 ){
-      raw_printf(stderr, "Usage: .show\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    utf8_printf(p->out, "%12.12s: %s\n","echo", p->echoOn ? "on" : "off");
-    utf8_printf(p->out, "%12.12s: %s\n","eqp", p->autoEQP ? "on" : "off");
-    utf8_printf(p->out,"%9.9s: %s\n","explain",p->normalMode.valid?"on":"off");
-    utf8_printf(p->out,"%12.12s: %s\n","headers", p->showHeader ? "on" : "off");
-    utf8_printf(p->out, "%12.12s: %s\n","mode", modeDescr[p->mode]);
-    utf8_printf(p->out, "%12.12s: ", "nullvalue");
-      output_c_string(p->out, p->nullValue);
-      raw_printf(p->out, "\n");
-    utf8_printf(p->out,"%12.12s: %s\n","output",
-            strlen30(p->outfile) ? p->outfile : "stdout");
-    utf8_printf(p->out,"%12.12s: ", "colseparator");
-      output_c_string(p->out, p->colSeparator);
-      raw_printf(p->out, "\n");
-    utf8_printf(p->out,"%12.12s: ", "rowseparator");
-      output_c_string(p->out, p->rowSeparator);
-      raw_printf(p->out, "\n");
-    utf8_printf(p->out, "%12.12s: %s\n","stats", p->statsOn ? "on" : "off");
-    utf8_printf(p->out, "%12.12s: ", "width");
-    for (i=0;i<(int)ArraySize(p->colWidth) && p->colWidth[i] != 0;i++) {
-      raw_printf(p->out, "%d ", p->colWidth[i]);
-    }
-    raw_printf(p->out, "\n");
-  }else
-
-  if( c=='s' && strncmp(azArg[0], "stats", n)==0 ){
-    if( nArg==2 ){
-      p->statsOn = booleanValue(azArg[1]);
-    }else{
-      raw_printf(stderr, "Usage: .stats on|off\n");
-      rc = 1;
-    }
-  }else
-
-  if( c=='t' && n>1 && strncmp(azArg[0], "tables", n)==0 ){
-    sqlite3_stmt *pStmt;
-    char **azResult;
-    int nRow, nAlloc;
-    char *zSql = 0;
-    int ii;
-    open_db(p, 0);
-    rc = sqlite3_prepare_v2(p->db, "PRAGMA database_list", -1, &pStmt, 0);
-    if( rc ) return shellDatabaseError(p->db);
-
-    /* Create an SQL statement to query for the list of tables in the
-    ** main and all attached databases where the table name matches the
-    ** LIKE pattern bound to variable "?1". */
-    zSql = sqlite3_mprintf(
-        "SELECT name FROM sqlite_master"
-        " WHERE type IN ('table','view')"
-        "   AND name NOT LIKE 'sqlite_%%'"
-        "   AND name LIKE ?1");
-    while( zSql && sqlite3_step(pStmt)==SQLITE_ROW ){
-      const char *zDbName = (const char*)sqlite3_column_text(pStmt, 1);
-      if( zDbName==0 || strcmp(zDbName,"main")==0 ) continue;
-      if( strcmp(zDbName,"temp")==0 ){
-        zSql = sqlite3_mprintf(
-                 "%z UNION ALL "
-                 "SELECT 'temp.' || name FROM sqlite_temp_master"
-                 " WHERE type IN ('table','view')"
-                 "   AND name NOT LIKE 'sqlite_%%'"
-                 "   AND name LIKE ?1", zSql);
-      }else{
-        zSql = sqlite3_mprintf(
-                 "%z UNION ALL "
-                 "SELECT '%q.' || name FROM \"%w\".sqlite_master"
-                 " WHERE type IN ('table','view')"
-                 "   AND name NOT LIKE 'sqlite_%%'"
-                 "   AND name LIKE ?1", zSql, zDbName, zDbName);
-      }
-    }
-    rc = sqlite3_finalize(pStmt);
-    if( zSql && rc==SQLITE_OK ){
-      zSql = sqlite3_mprintf("%z ORDER BY 1", zSql);
-      if( zSql ) rc = sqlite3_prepare_v2(p->db, zSql, -1, &pStmt, 0);
-    }
-    sqlite3_free(zSql);
-    if( !zSql ) return shellNomemError();
-    if( rc ) return shellDatabaseError(p->db);
-
-    /* Run the SQL statement prepared by the above block. Store the results
-    ** as an array of nul-terminated strings in azResult[].  */
-    nRow = nAlloc = 0;
-    azResult = 0;
-    if( nArg>1 ){
-      sqlite3_bind_text(pStmt, 1, azArg[1], -1, SQLITE_TRANSIENT);
-    }else{
-      sqlite3_bind_text(pStmt, 1, "%", -1, SQLITE_STATIC);
-    }
-    while( sqlite3_step(pStmt)==SQLITE_ROW ){
-      if( nRow>=nAlloc ){
-        char **azNew;
-        int n2 = nAlloc*2 + 10;
-        azNew = sqlite3_realloc64(azResult, sizeof(azResult[0])*n2);
-        if( azNew==0 ){
-          rc = shellNomemError();
-          break;
-        }
-        nAlloc = n2;
-        azResult = azNew;
-      }
-      azResult[nRow] = sqlite3_mprintf("%s", sqlite3_column_text(pStmt, 0));
-      if( 0==azResult[nRow] ){
-        rc = shellNomemError();
-        break;
-      }
-      nRow++;
-    }
-    if( sqlite3_finalize(pStmt)!=SQLITE_OK ){
-      rc = shellDatabaseError(p->db);
-    }
-
-    /* Pretty-print the contents of array azResult[] to the output */
-    if( rc==0 && nRow>0 ){
-      int len, maxlen = 0;
-      int i, j;
-      int nPrintCol, nPrintRow;
-      for(i=0; i<nRow; i++){
-        len = strlen30(azResult[i]);
-        if( len>maxlen ) maxlen = len;
-      }
-      nPrintCol = 80/(maxlen+2);
-      if( nPrintCol<1 ) nPrintCol = 1;
-      nPrintRow = (nRow + nPrintCol - 1)/nPrintCol;
-      for(i=0; i<nPrintRow; i++){
-        for(j=i; j<nRow; j+=nPrintRow){
-          char *zSp = j<nPrintRow ? "" : "  ";
-          utf8_printf(p->out, "%s%-*s", zSp, maxlen,
-                      azResult[j] ? azResult[j]:"");
-        }
-        raw_printf(p->out, "\n");
-      }
-    }
-
-    for(ii=0; ii<nRow; ii++) sqlite3_free(azResult[ii]);
-    sqlite3_free(azResult);
-  }else
-
-  if( c=='t' && n>=8 && strncmp(azArg[0], "testctrl", n)==0 && nArg>=2 ){
-    static const struct {
-       const char *zCtrlName;   /* Name of a test-control option */
-       int ctrlCode;            /* Integer code for that option */
-    } aCtrl[] = {
-      { "prng_save",             SQLITE_TESTCTRL_PRNG_SAVE              },
-      { "prng_restore",          SQLITE_TESTCTRL_PRNG_RESTORE           },
-      { "prng_reset",            SQLITE_TESTCTRL_PRNG_RESET             },
-      { "bitvec_test",           SQLITE_TESTCTRL_BITVEC_TEST            },
-      { "fault_install",         SQLITE_TESTCTRL_FAULT_INSTALL          },
-      { "benign_malloc_hooks",   SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS    },
-      { "pending_byte",          SQLITE_TESTCTRL_PENDING_BYTE           },
-      { "assert",                SQLITE_TESTCTRL_ASSERT                 },
-      { "always",                SQLITE_TESTCTRL_ALWAYS                 },
-      { "reserve",               SQLITE_TESTCTRL_RESERVE                },
-      { "optimizations",         SQLITE_TESTCTRL_OPTIMIZATIONS          },
-      { "iskeyword",             SQLITE_TESTCTRL_ISKEYWORD              },
-      { "scratchmalloc",         SQLITE_TESTCTRL_SCRATCHMALLOC          },
-      { "byteorder",             SQLITE_TESTCTRL_BYTEORDER              },
-      { "never_corrupt",         SQLITE_TESTCTRL_NEVER_CORRUPT          },
-      { "imposter",              SQLITE_TESTCTRL_IMPOSTER               },
-    };
-    int testctrl = -1;
-    int rc2 = 0;
-    int i, n2;
-    open_db(p, 0);
-
-    /* convert testctrl text option to value. allow any unique prefix
-    ** of the option name, or a numerical value. */
-    n2 = strlen30(azArg[1]);
-    for(i=0; i<ArraySize(aCtrl); i++){
-      if( strncmp(azArg[1], aCtrl[i].zCtrlName, n2)==0 ){
-        if( testctrl<0 ){
-          testctrl = aCtrl[i].ctrlCode;
-        }else{
-          utf8_printf(stderr, "ambiguous option name: \"%s\"\n", azArg[1]);
-          testctrl = -1;
-          break;
-        }
-      }
-    }
-    if( testctrl<0 ) testctrl = (int)integerValue(azArg[1]);
-    if( (testctrl<SQLITE_TESTCTRL_FIRST) || (testctrl>SQLITE_TESTCTRL_LAST) ){
-      utf8_printf(stderr,"Error: invalid testctrl option: %s\n", azArg[1]);
-    }else{
-      switch(testctrl){
-
-        /* sqlite3_test_control(int, db, int) */
-        case SQLITE_TESTCTRL_OPTIMIZATIONS:
-        case SQLITE_TESTCTRL_RESERVE:             
-          if( nArg==3 ){
-            int opt = (int)strtol(azArg[2], 0, 0);        
-            rc2 = sqlite3_test_control(testctrl, p->db, opt);
-            raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
-          } else {
-            utf8_printf(stderr,"Error: testctrl %s takes a single int option\n",
-                    azArg[1]);
-          }
-          break;
-
-        /* sqlite3_test_control(int) */
-        case SQLITE_TESTCTRL_PRNG_SAVE:
-        case SQLITE_TESTCTRL_PRNG_RESTORE:
-        case SQLITE_TESTCTRL_PRNG_RESET:
-        case SQLITE_TESTCTRL_BYTEORDER:
-          if( nArg==2 ){
-            rc2 = sqlite3_test_control(testctrl);
-            raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
-          } else {
-            utf8_printf(stderr,"Error: testctrl %s takes no options\n",
-                        azArg[1]);
-          }
-          break;
-
-        /* sqlite3_test_control(int, uint) */
-        case SQLITE_TESTCTRL_PENDING_BYTE:        
-          if( nArg==3 ){
-            unsigned int opt = (unsigned int)integerValue(azArg[2]);
-            rc2 = sqlite3_test_control(testctrl, opt);
-            raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
-          } else {
-            utf8_printf(stderr,"Error: testctrl %s takes a single unsigned"
-                           " int option\n", azArg[1]);
-          }
-          break;
-          
-        /* sqlite3_test_control(int, int) */
-        case SQLITE_TESTCTRL_ASSERT:              
-        case SQLITE_TESTCTRL_ALWAYS:      
-        case SQLITE_TESTCTRL_NEVER_CORRUPT:        
-          if( nArg==3 ){
-            int opt = booleanValue(azArg[2]);        
-            rc2 = sqlite3_test_control(testctrl, opt);
-            raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
-          } else {
-            utf8_printf(stderr,"Error: testctrl %s takes a single int option\n",
-                            azArg[1]);
-          }
-          break;
-
-        /* sqlite3_test_control(int, char *) */
-#ifdef SQLITE_N_KEYWORD
-        case SQLITE_TESTCTRL_ISKEYWORD:           
-          if( nArg==3 ){
-            const char *opt = azArg[2];        
-            rc2 = sqlite3_test_control(testctrl, opt);
-            raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
-          } else {
-            utf8_printf(stderr,
-                        "Error: testctrl %s takes a single char * option\n",
-                        azArg[1]);
-          }
-          break;
-#endif
-
-        case SQLITE_TESTCTRL_IMPOSTER:
-          if( nArg==5 ){
-            rc2 = sqlite3_test_control(testctrl, p->db, 
-                          azArg[2],
-                          integerValue(azArg[3]),
-                          integerValue(azArg[4]));
-            raw_printf(p->out, "%d (0x%08x)\n", rc2, rc2);
-          }else{
-            raw_printf(stderr,"Usage: .testctrl imposter dbName onoff tnum\n");
-          }
-          break;
-
-        case SQLITE_TESTCTRL_BITVEC_TEST:         
-        case SQLITE_TESTCTRL_FAULT_INSTALL:       
-        case SQLITE_TESTCTRL_BENIGN_MALLOC_HOOKS: 
-        case SQLITE_TESTCTRL_SCRATCHMALLOC:       
-        default:
-          utf8_printf(stderr,
-                      "Error: CLI support for testctrl %s not implemented\n",
-                      azArg[1]);
-          break;
-      }
-    }
-  }else
-
-  if( c=='t' && n>4 && strncmp(azArg[0], "timeout", n)==0 ){
-    open_db(p, 0);
-    sqlite3_busy_timeout(p->db, nArg>=2 ? (int)integerValue(azArg[1]) : 0);
-  }else
-    
-  if( c=='t' && n>=5 && strncmp(azArg[0], "timer", n)==0 ){
-    if( nArg==2 ){
-      enableTimer = booleanValue(azArg[1]);
-      if( enableTimer && !HAS_TIMER ){
-        raw_printf(stderr, "Error: timer not available on this system.\n");
-        enableTimer = 0;
-      }
-    }else{
-      raw_printf(stderr, "Usage: .timer on|off\n");
-      rc = 1;
-    }
-  }else
-  
-  if( c=='t' && strncmp(azArg[0], "trace", n)==0 ){
-    open_db(p, 0);
-    if( nArg!=2 ){
-      raw_printf(stderr, "Usage: .trace FILE|off\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    output_file_close(p->traceOut);
-    p->traceOut = output_file_open(azArg[1]);
-#if !defined(SQLITE_OMIT_TRACE) && !defined(SQLITE_OMIT_FLOATING_POINT)
-    if( p->traceOut==0 ){
-      sqlite3_trace(p->db, 0, 0);
-    }else{
-      sqlite3_trace(p->db, sql_trace_callback, p->traceOut);
-    }
-#endif
-  }else
-
-#if SQLITE_USER_AUTHENTICATION
-  if( c=='u' && strncmp(azArg[0], "user", n)==0 ){
-    if( nArg<2 ){
-      raw_printf(stderr, "Usage: .user SUBCOMMAND ...\n");
-      rc = 1;
-      goto meta_command_exit;
-    }
-    open_db(p, 0);
-    if( strcmp(azArg[1],"login")==0 ){
-      if( nArg!=4 ){
-        raw_printf(stderr, "Usage: .user login USER PASSWORD\n");
-        rc = 1;
-        goto meta_command_exit;
-      }
-      rc = sqlite3_user_authenticate(p->db, azArg[2], azArg[3],
-                                    (int)strlen(azArg[3]));
-      if( rc ){
-        utf8_printf(stderr, "Authentication failed for user %s\n", azArg[2]);
-        rc = 1;
-      }
-    }else if( strcmp(azArg[1],"add")==0 ){
-      if( nArg!=5 ){
-        raw_printf(stderr, "Usage: .user add USER PASSWORD ISADMIN\n");
-        rc = 1;
-        goto meta_command_exit;
-      }
-      rc = sqlite3_user_add(p->db, azArg[2],
-                            azArg[3], (int)strlen(azArg[3]),
-                            booleanValue(azArg[4]));
-      if( rc ){
-        raw_printf(stderr, "User-Add failed: %d\n", rc);
-        rc = 1;
-      }
-    }else if( strcmp(azArg[1],"edit")==0 ){
-      if( nArg!=5 ){
-        raw_printf(stderr, "Usage: .user edit USER PASSWORD ISADMIN\n");
-        rc = 1;
-        goto meta_command_exit;
-      }
-      rc = sqlite3_user_change(p->db, azArg[2],
-                              azArg[3], (int)strlen(azArg[3]),
-                              booleanValue(azArg[4]));
-      if( rc ){
-        raw_printf(stderr, "User-Edit failed: %d\n", rc);
-        rc = 1;
-      }
-    }else if( strcmp(azArg[1],"delete")==0 ){
-      if( nArg!=3 ){
-        raw_printf(stderr, "Usage: .user delete USER\n");
-        rc = 1;
-        goto meta_command_exit;
-      }
-      rc = sqlite3_user_delete(p->db, azArg[2]);
-      if( rc ){
-        raw_printf(stderr, "User-Delete failed: %d\n", rc);
-        rc = 1;
-      }
-    }else{
-      raw_printf(stderr, "Usage: .user login|add|edit|delete ...\n");
-      rc = 1;
-      goto meta_command_exit;
-    }    
-  }else
-#endif /* SQLITE_USER_AUTHENTICATION */
-
-  if( c=='v' && strncmp(azArg[0], "version", n)==0 ){
-    utf8_printf(p->out, "SQLite %s %s\n" /*extra-version-info*/,
-        sqlite3_libversion(), sqlite3_sourceid());
-  }else
-
-  if( c=='v' && strncmp(azArg[0], "vfsinfo", n)==0 ){
-    const char *zDbName = nArg==2 ? azArg[1] : "main";
-    sqlite3_vfs *pVfs;
-    if( p->db ){
-      sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFS_POINTER, &pVfs);
-      if( pVfs ){
-        utf8_printf(p->out, "vfs.zName      = \"%s\"\n", pVfs->zName);
-        raw_printf(p->out, "vfs.iVersion   = %d\n", pVfs->iVersion);
-        raw_printf(p->out, "vfs.szOsFile   = %d\n", pVfs->szOsFile);
-        raw_printf(p->out, "vfs.mxPathname = %d\n", pVfs->mxPathname);
-      }
-    }
-  }else
-
-  if( c=='v' && strncmp(azArg[0], "vfsname", n)==0 ){
-    const char *zDbName = nArg==2 ? azArg[1] : "main";
-    char *zVfsName = 0;
-    if( p->db ){
-      sqlite3_file_control(p->db, zDbName, SQLITE_FCNTL_VFSNAME, &zVfsName);
-      if( zVfsName ){
-        utf8_printf(p->out, "%s\n", zVfsName);
-        sqlite3_free(zVfsName);
-      }
-    }
-  }else
-
-#if defined(SQLITE_DEBUG) && defined(SQLITE_ENABLE_WHERETRACE)
-  if( c=='w' && strncmp(azArg[0], "wheretrace", n)==0 ){
-    extern int sqlite3WhereTrace;
-    sqlite3WhereTrace = nArg>=2 ? booleanValue(azArg[1]) : 0xff;
-  }else
-#endif
-
-  if( c=='w' && strncmp(azArg[0], "width", n)==0 ){
-    int j;
-    assert( nArg<=ArraySize(azArg) );
-    for(j=1; j<nArg && j<ArraySize(p->colWidth); j++){
-      p->colWidth[j-1] = (int)integerValue(azArg[j]);
-    }
-  }else
-
-  {
-    utf8_printf(stderr, "Error: unknown command or invalid arguments: "
-      " \"%s\". Enter \".help\" for help\n", azArg[0]);
-    rc = 1;
-  }
-
-meta_command_exit:
-  if( p->outCount ){
-    p->outCount--;
-    if( p->outCount==0 ) output_reset(p);
-  }
-  return rc;
-}
-
-/*
-** Return TRUE if a semicolon occurs anywhere in the first N characters
-** of string z[].
-*/
-static int line_contains_semicolon(const char *z, int N){
-  int i;
-  for(i=0; i<N; i++){  if( z[i]==';' ) return 1; }
-  return 0;
-}
-
-/*
-** Test to see if a line consists entirely of whitespace.
-*/
-static int _all_whitespace(const char *z){
-  for(; *z; z++){
-    if( IsSpace(z[0]) ) continue;
-    if( *z=='/' && z[1]=='*' ){
-      z += 2;
-      while( *z && (*z!='*' || z[1]!='/') ){ z++; }
-      if( *z==0 ) return 0;
-      z++;
-      continue;
-    }
-    if( *z=='-' && z[1]=='-' ){
-      z += 2;
-      while( *z && *z!='\n' ){ z++; }
-      if( *z==0 ) return 1;
-      continue;
-    }
-    return 0;
-  }
-  return 1;
-}
-
-/*
-** Return TRUE if the line typed in is an SQL command terminator other
-** than a semi-colon.  The SQL Server style "go" command is understood
-** as is the Oracle "/".
-*/
-static int line_is_command_terminator(const char *zLine){
-  while( IsSpace(zLine[0]) ){ zLine++; };
-  if( zLine[0]=='/' && _all_whitespace(&zLine[1]) ){
-    return 1;  /* Oracle */
-  }
-  if( ToLower(zLine[0])=='g' && ToLower(zLine[1])=='o'
-         && _all_whitespace(&zLine[2]) ){
-    return 1;  /* SQL Server */
-  }
-  return 0;
-}
-
-/*
-** Return true if zSql is a complete SQL statement.  Return false if it
-** ends in the middle of a string literal or C-style comment.
-*/
-static int line_is_complete(char *zSql, int nSql){
-  int rc;
-  if( zSql==0 ) return 1;
-  zSql[nSql] = ';';
-  zSql[nSql+1] = 0;
-  rc = sqlite3_complete(zSql);
-  zSql[nSql] = 0;
-  return rc;
-}
-
-/*
-** Read input from *in and process it.  If *in==0 then input
-** is interactive - the user is typing it it.  Otherwise, input
-** is coming from a file or device.  A prompt is issued and history
-** is saved only if input is interactive.  An interrupt signal will
-** cause this routine to exit immediately, unless input is interactive.
-**
-** Return the number of errors.
-*/
-static int process_input(ShellState *p, FILE *in){
-  char *zLine = 0;          /* A single input line */
-  char *zSql = 0;           /* Accumulated SQL text */
-  int nLine;                /* Length of current line */
-  int nSql = 0;             /* Bytes of zSql[] used */
-  int nAlloc = 0;           /* Allocated zSql[] space */
-  int nSqlPrior = 0;        /* Bytes of zSql[] used by prior line */
-  char *zErrMsg;            /* Error message returned */
-  int rc;                   /* Error code */
-  int errCnt = 0;           /* Number of errors seen */
-  int lineno = 0;           /* Current line number */
-  int startline = 0;        /* Line number for start of current input */
-
-  while( errCnt==0 || !bail_on_error || (in==0 && stdin_is_interactive) ){
-    fflush(p->out);
-    zLine = one_input_line(in, zLine, nSql>0);
-    if( zLine==0 ){
-      /* End of input */
-      if( stdin_is_interactive ) printf("\n");
-      break;
-    }
-    if( seenInterrupt ){
-      if( in!=0 ) break;
-      seenInterrupt = 0;
-    }
-    lineno++;
-    if( nSql==0 && _all_whitespace(zLine) ){
-      if( p->echoOn ) printf("%s\n", zLine);
-      continue;
-    }
-    if( zLine && zLine[0]=='.' && nSql==0 ){
-      if( p->echoOn ) printf("%s\n", zLine);
-      rc = do_meta_command(zLine, p);
-      if( rc==2 ){ /* exit requested */
-        break;
-      }else if( rc ){
-        errCnt++;
-      }
-      continue;
-    }
-    if( line_is_command_terminator(zLine) && line_is_complete(zSql, nSql) ){
-      memcpy(zLine,";",2);
-    }
-    nLine = strlen30(zLine);
-    if( nSql+nLine+2>=nAlloc ){
-      nAlloc = nSql+nLine+100;
-      zSql = realloc(zSql, nAlloc);
-      if( zSql==0 ){
-        raw_printf(stderr, "Error: out of memory\n");
-        exit(1);
-      }
-    }
-    nSqlPrior = nSql;
-    if( nSql==0 ){
-      int i;
-      for(i=0; zLine[i] && IsSpace(zLine[i]); i++){}
-      assert( nAlloc>0 && zSql!=0 );
-      memcpy(zSql, zLine+i, nLine+1-i);
-      startline = lineno;
-      nSql = nLine-i;
-    }else{
-      zSql[nSql++] = '\n';
-      memcpy(zSql+nSql, zLine, nLine+1);
-      nSql += nLine;
-    }
-    if( nSql && line_contains_semicolon(&zSql[nSqlPrior], nSql-nSqlPrior)
-                && sqlite3_complete(zSql) ){
-      p->cnt = 0;
-      open_db(p, 0);
-      if( p->backslashOn ) resolve_backslashes(zSql);
-      BEGIN_TIMER;
-      rc = shell_exec(p->db, zSql, shell_callback, p, &zErrMsg);
-      END_TIMER;
-      if( rc || zErrMsg ){
-        char zPrefix[100];
-        if( in!=0 || !stdin_is_interactive ){
-          sqlite3_snprintf(sizeof(zPrefix), zPrefix, 
-                           "Error: near line %d:", startline);
-        }else{
-          sqlite3_snprintf(sizeof(zPrefix), zPrefix, "Error:");
-        }
-        if( zErrMsg!=0 ){
-          utf8_printf(stderr, "%s %s\n", zPrefix, zErrMsg);
-          sqlite3_free(zErrMsg);
-          zErrMsg = 0;
-        }else{
-          utf8_printf(stderr, "%s %s\n", zPrefix, sqlite3_errmsg(p->db));
-        }
-        errCnt++;
-      }else if( p->countChanges ){
-        raw_printf(p->out, "changes: %3d   total_changes: %d\n",
-                sqlite3_changes(p->db), sqlite3_total_changes(p->db));
-      }
-      nSql = 0;
-      if( p->outCount ){
-        output_reset(p);
-        p->outCount = 0;
-      }
-    }else if( nSql && _all_whitespace(zSql) ){
-      if( p->echoOn ) printf("%s\n", zSql);
-      nSql = 0;
-    }
-  }
-  if( nSql ){
-    if( !_all_whitespace(zSql) ){
-      utf8_printf(stderr, "Error: incomplete SQL: %s\n", zSql);
-      errCnt++;
-    }
-  }
-  free(zSql);
-  free(zLine);
-  return errCnt>0;
-}
-
-/*
-** Return a pathname which is the user's home directory.  A
-** 0 return indicates an error of some kind.
-*/
-static char *find_home_dir(void){
-  static char *home_dir = NULL;
-  if( home_dir ) return home_dir;
-
-#if !defined(_WIN32) && !defined(WIN32) && !defined(_WIN32_WCE) \
-     && !defined(__RTP__) && !defined(_WRS_KERNEL)
-  {
-    struct passwd *pwent;
-    uid_t uid = getuid();
-    if( (pwent=getpwuid(uid)) != NULL) {
-      home_dir = pwent->pw_dir;
-    }
-  }
-#endif
-
-#if defined(_WIN32_WCE)
-  /* Windows CE (arm-wince-mingw32ce-gcc) does not provide getenv()
-   */
-  home_dir = "/";
-#else
-
-#if defined(_WIN32) || defined(WIN32)
-  if (!home_dir) {
-    home_dir = getenv("USERPROFILE");
-  }
-#endif
-
-  if (!home_dir) {
-    home_dir = getenv("HOME");
-  }
-
-#if defined(_WIN32) || defined(WIN32)
-  if (!home_dir) {
-    char *zDrive, *zPath;
-    int n;
-    zDrive = getenv("HOMEDRIVE");
-    zPath = getenv("HOMEPATH");
-    if( zDrive && zPath ){
-      n = strlen30(zDrive) + strlen30(zPath) + 1;
-      home_dir = malloc( n );
-      if( home_dir==0 ) return 0;
-      sqlite3_snprintf(n, home_dir, "%s%s", zDrive, zPath);
-      return home_dir;
-    }
-    home_dir = "c:\\";
-  }
-#endif
-
-#endif /* !_WIN32_WCE */
-
-  if( home_dir ){
-    int n = strlen30(home_dir) + 1;
-    char *z = malloc( n );
-    if( z ) memcpy(z, home_dir, n);
-    home_dir = z;
-  }
-
-  return home_dir;
-}
-
-/*
-** Read input from the file given by sqliterc_override.  Or if that
-** parameter is NULL, take input from ~/.sqliterc
-**
-** Returns the number of errors.
-*/
-static void process_sqliterc(
-  ShellState *p,                  /* Configuration data */
-  const char *sqliterc_override   /* Name of config file. NULL to use default */
-){
-  char *home_dir = NULL;
-  const char *sqliterc = sqliterc_override;
-  char *zBuf = 0;
-  FILE *in = NULL;
-
-  if (sqliterc == NULL) {
-    home_dir = find_home_dir();
-    if( home_dir==0 ){
-      raw_printf(stderr, "-- warning: cannot find home directory;"
-                      " cannot read ~/.sqliterc\n");
-      return;
-    }
-    sqlite3_initialize();
-    zBuf = sqlite3_mprintf("%s/.sqliterc",home_dir);
-    sqliterc = zBuf;
-  }
-  in = fopen(sqliterc,"rb");
-  if( in ){
-    if( stdin_is_interactive ){
-      utf8_printf(stderr,"-- Loading resources from %s\n",sqliterc);
-    }
-    process_input(p,in);
-    fclose(in);
-  }
-  sqlite3_free(zBuf);
-}
-
-/*
-** Show available command line options
-*/
-static const char zOptions[] = 
-  "   -ascii               set output mode to 'ascii'\n"
-  "   -bail                stop after hitting an error\n"
-  "   -batch               force batch I/O\n"
-  "   -column              set output mode to 'column'\n"
-  "   -cmd COMMAND         run \"COMMAND\" before reading stdin\n"
-  "   -csv                 set output mode to 'csv'\n"
-  "   -echo                print commands before execution\n"
-  "   -init FILENAME       read/process named file\n"
-  "   -[no]header          turn headers on or off\n"
-#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
-  "   -heap SIZE           Size of heap for memsys3 or memsys5\n"
-#endif
-  "   -help                show this message\n"
-  "   -html                set output mode to HTML\n"
-  "   -interactive         force interactive I/O\n"
-  "   -line                set output mode to 'line'\n"
-  "   -list                set output mode to 'list'\n"
-  "   -lookaside SIZE N    use N entries of SZ bytes for lookaside memory\n"
-  "   -mmap N              default mmap size set to N\n"
-#ifdef SQLITE_ENABLE_MULTIPLEX
-  "   -multiplex           enable the multiplexor VFS\n"
-#endif
-  "   -newline SEP         set output row separator. Default: '\\n'\n"
-  "   -nullvalue TEXT      set text string for NULL values. Default ''\n"
-  "   -pagecache SIZE N    use N slots of SZ bytes each for page cache memory\n"
-  "   -scratch SIZE N      use N slots of SZ bytes each for scratch memory\n"
-  "   -separator SEP       set output column separator. Default: '|'\n"
-  "   -stats               print memory stats before each finalize\n"
-  "   -version             show SQLite version\n"
-  "   -vfs NAME            use NAME as the default VFS\n"
-#ifdef SQLITE_ENABLE_VFSTRACE
-  "   -vfstrace            enable tracing of all VFS calls\n"
-#endif
-;
-static void usage(int showDetail){
-  utf8_printf(stderr,
-      "Usage: %s [OPTIONS] FILENAME [SQL]\n"  
-      "FILENAME is the name of an SQLite database. A new database is created\n"
-      "if the file does not previously exist.\n", Argv0);
-  if( showDetail ){
-    utf8_printf(stderr, "OPTIONS include:\n%s", zOptions);
-  }else{
-    raw_printf(stderr, "Use the -help option for additional information\n");
-  }
-  exit(1);
-}
-
-/*
-** Initialize the state information in data
-*/
-static void main_init(ShellState *data) {
-  memset(data, 0, sizeof(*data));
-  data->mode = MODE_List;
-  memcpy(data->colSeparator,SEP_Column, 2);
-  memcpy(data->rowSeparator,SEP_Row, 2);
-  data->showHeader = 0;
-  data->shellFlgs = SHFLG_Lookaside;
-  sqlite3_config(SQLITE_CONFIG_URI, 1);
-  sqlite3_config(SQLITE_CONFIG_LOG, shellLog, data);
-  sqlite3_config(SQLITE_CONFIG_MULTITHREAD);
-  sqlite3_snprintf(sizeof(mainPrompt), mainPrompt,"sqlite> ");
-  sqlite3_snprintf(sizeof(continuePrompt), continuePrompt,"   ...> ");
-}
-
-/*
-** Output text to the console in a font that attracts extra attention.
-*/
-#ifdef _WIN32
-static void printBold(const char *zText){
-  HANDLE out = GetStdHandle(STD_OUTPUT_HANDLE);
-  CONSOLE_SCREEN_BUFFER_INFO defaultScreenInfo;
-  GetConsoleScreenBufferInfo(out, &defaultScreenInfo);
-  SetConsoleTextAttribute(out,
-         FOREGROUND_RED|FOREGROUND_INTENSITY
-  );
-  printf("%s", zText);
-  SetConsoleTextAttribute(out, defaultScreenInfo.wAttributes);
-}
-#else
-static void printBold(const char *zText){
-  printf("\033[1m%s\033[0m", zText);
-}
-#endif
-
-/*
-** Get the argument to an --option.  Throw an error and die if no argument
-** is available.
-*/
-static char *cmdline_option_value(int argc, char **argv, int i){
-  if( i==argc ){
-    utf8_printf(stderr, "%s: Error: missing argument to %s\n",
-            argv[0], argv[argc-1]);
-    exit(1);
-  }
-  return argv[i];
-}
-
-int SQLITE_CDECL main(int argc, char **argv){
-  char *zErrMsg = 0;
-  ShellState data;
-  const char *zInitFile = 0;
-  int i;
-  int rc = 0;
-  int warnInmemoryDb = 0;
-  int readStdin = 1;
-  int nCmd = 0;
-  char **azCmd = 0;
-
-#if USE_SYSTEM_SQLITE+0!=1
-  if( strcmp(sqlite3_sourceid(),SQLITE_SOURCE_ID)!=0 ){
-    utf8_printf(stderr, "SQLite header and source version mismatch\n%s\n%s\n",
-            sqlite3_sourceid(), SQLITE_SOURCE_ID);
-    exit(1);
-  }
-#endif
-  setBinaryMode(stdin);
-  setvbuf(stderr, 0, _IONBF, 0); /* Make sure stderr is unbuffered */
-  Argv0 = argv[0];
-  main_init(&data);
-  stdin_is_interactive = isatty(0);
-  stdout_is_console = isatty(1);
-
-  /* Make sure we have a valid signal handler early, before anything
-  ** else is done.
-  */
-#ifdef SIGINT
-  signal(SIGINT, interrupt_handler);
-#endif
-
-#ifdef SQLITE_SHELL_DBNAME_PROC
-  {
-    /* If the SQLITE_SHELL_DBNAME_PROC macro is defined, then it is the name
-    ** of a C-function that will provide the name of the database file.  Use
-    ** this compile-time option to embed this shell program in larger
-    ** applications. */
-    extern void SQLITE_SHELL_DBNAME_PROC(const char**);
-    SQLITE_SHELL_DBNAME_PROC(&data.zDbFilename);
-    warnInmemoryDb = 0;
-  }
-#endif
-
-  /* Do an initial pass through the command-line argument to locate
-  ** the name of the database file, the name of the initialization file,
-  ** the size of the alternative malloc heap,
-  ** and the first command to execute.
-  */
-  for(i=1; i<argc; i++){
-    char *z;
-    z = argv[i];
-    if( z[0]!='-' ){
-      if( data.zDbFilename==0 ){
-        data.zDbFilename = z;
-      }else{
-        /* Excesss arguments are interpreted as SQL (or dot-commands) and
-        ** mean that nothing is read from stdin */
-        readStdin = 0;
-        nCmd++;
-        azCmd = realloc(azCmd, sizeof(azCmd[0])*nCmd);
-        if( azCmd==0 ){
-          raw_printf(stderr, "out of memory\n");
-          exit(1);
-        }
-        azCmd[nCmd-1] = z;
-      }
-    }
-    if( z[1]=='-' ) z++;
-    if( strcmp(z,"-separator")==0
-     || strcmp(z,"-nullvalue")==0
-     || strcmp(z,"-newline")==0
-     || strcmp(z,"-cmd")==0
-    ){
-      (void)cmdline_option_value(argc, argv, ++i);
-    }else if( strcmp(z,"-init")==0 ){
-      zInitFile = cmdline_option_value(argc, argv, ++i);
-    }else if( strcmp(z,"-batch")==0 ){
-      /* Need to check for batch mode here to so we can avoid printing
-      ** informational messages (like from process_sqliterc) before 
-      ** we do the actual processing of arguments later in a second pass.
-      */
-      stdin_is_interactive = 0;
-    }else if( strcmp(z,"-heap")==0 ){
-#if defined(SQLITE_ENABLE_MEMSYS3) || defined(SQLITE_ENABLE_MEMSYS5)
-      const char *zSize;
-      sqlite3_int64 szHeap;
-
-      zSize = cmdline_option_value(argc, argv, ++i);
-      szHeap = integerValue(zSize);
-      if( szHeap>0x7fff0000 ) szHeap = 0x7fff0000;
-      sqlite3_config(SQLITE_CONFIG_HEAP, malloc((int)szHeap), (int)szHeap, 64);
-#endif
-    }else if( strcmp(z,"-scratch")==0 ){
-      int n, sz;
-      sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
-      if( sz>400000 ) sz = 400000;
-      if( sz<2500 ) sz = 2500;
-      n = (int)integerValue(cmdline_option_value(argc,argv,++i));
-      if( n>10 ) n = 10;
-      if( n<1 ) n = 1;
-      sqlite3_config(SQLITE_CONFIG_SCRATCH, malloc(n*sz+1), sz, n);
-      data.shellFlgs |= SHFLG_Scratch;
-    }else if( strcmp(z,"-pagecache")==0 ){
-      int n, sz;
-      sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
-      if( sz>70000 ) sz = 70000;
-      if( sz<0 ) sz = 0;
-      n = (int)integerValue(cmdline_option_value(argc,argv,++i));
-      sqlite3_config(SQLITE_CONFIG_PAGECACHE,
-                    (n>0 && sz>0) ? malloc(n*sz) : 0, sz, n);
-      data.shellFlgs |= SHFLG_Pagecache;
-    }else if( strcmp(z,"-lookaside")==0 ){
-      int n, sz;
-      sz = (int)integerValue(cmdline_option_value(argc,argv,++i));
-      if( sz<0 ) sz = 0;
-      n = (int)integerValue(cmdline_option_value(argc,argv,++i));
-      if( n<0 ) n = 0;
-      sqlite3_config(SQLITE_CONFIG_LOOKASIDE, sz, n);
-      if( sz*n==0 ) data.shellFlgs &= ~SHFLG_Lookaside;
-#ifdef SQLITE_ENABLE_VFSTRACE
-    }else if( strcmp(z,"-vfstrace")==0 ){
-      extern int vfstrace_register(
-         const char *zTraceName,
-         const char *zOldVfsName,
-         int (*xOut)(const char*,void*),
-         void *pOutArg,
-         int makeDefault
-      );
-      vfstrace_register("trace",0,(int(*)(const char*,void*))fputs,stderr,1);
-#endif
-#ifdef SQLITE_ENABLE_MULTIPLEX
-    }else if( strcmp(z,"-multiplex")==0 ){
-      extern int sqlite3_multiple_initialize(const char*,int);
-      sqlite3_multiplex_initialize(0, 1);
-#endif
-    }else if( strcmp(z,"-mmap")==0 ){
-      sqlite3_int64 sz = integerValue(cmdline_option_value(argc,argv,++i));
-      sqlite3_config(SQLITE_CONFIG_MMAP_SIZE, sz, sz);
-    }else if( strcmp(z,"-vfs")==0 ){
-      sqlite3_vfs *pVfs = sqlite3_vfs_find(cmdline_option_value(argc,argv,++i));
-      if( pVfs ){
-        sqlite3_vfs_register(pVfs, 1);
-      }else{
-        utf8_printf(stderr, "no such VFS: \"%s\"\n", argv[i]);
-        exit(1);
-      }
-    }
-  }
-  if( data.zDbFilename==0 ){
-#ifndef SQLITE_OMIT_MEMORYDB
-    data.zDbFilename = ":memory:";
-    warnInmemoryDb = argc==1;
-#else
-    utf8_printf(stderr,"%s: Error: no database filename specified\n", Argv0);
-    return 1;
-#endif
-  }
-  data.out = stdout;
-
-  /* Go ahead and open the database file if it already exists.  If the
-  ** file does not exist, delay opening it.  This prevents empty database
-  ** files from being created if a user mistypes the database name argument
-  ** to the sqlite command-line tool.
-  */
-  if( access(data.zDbFilename, 0)==0 ){
-    open_db(&data, 0);
-  }
-
-  /* Process the initialization file if there is one.  If no -init option
-  ** is given on the command line, look for a file named ~/.sqliterc and
-  ** try to process it.
-  */
-  process_sqliterc(&data,zInitFile);
-
-  /* Make a second pass through the command-line argument and set
-  ** options.  This second pass is delayed until after the initialization
-  ** file is processed so that the command-line arguments will override
-  ** settings in the initialization file.
-  */
-  for(i=1; i<argc; i++){
-    char *z = argv[i];
-    if( z[0]!='-' ) continue;
-    if( z[1]=='-' ){ z++; }
-    if( strcmp(z,"-init")==0 ){
-      i++;
-    }else if( strcmp(z,"-html")==0 ){
-      data.mode = MODE_Html;
-    }else if( strcmp(z,"-list")==0 ){
-      data.mode = MODE_List;
-    }else if( strcmp(z,"-line")==0 ){
-      data.mode = MODE_Line;
-    }else if( strcmp(z,"-column")==0 ){
-      data.mode = MODE_Column;
-    }else if( strcmp(z,"-csv")==0 ){
-      data.mode = MODE_Csv;
-      memcpy(data.colSeparator,",",2);
-    }else if( strcmp(z,"-ascii")==0 ){
-      data.mode = MODE_Ascii;
-      sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
-                       SEP_Unit);
-      sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
-                       SEP_Record);
-    }else if( strcmp(z,"-separator")==0 ){
-      sqlite3_snprintf(sizeof(data.colSeparator), data.colSeparator,
-                       "%s",cmdline_option_value(argc,argv,++i));
-    }else if( strcmp(z,"-newline")==0 ){
-      sqlite3_snprintf(sizeof(data.rowSeparator), data.rowSeparator,
-                       "%s",cmdline_option_value(argc,argv,++i));
-    }else if( strcmp(z,"-nullvalue")==0 ){
-      sqlite3_snprintf(sizeof(data.nullValue), data.nullValue,
-                       "%s",cmdline_option_value(argc,argv,++i));
-    }else if( strcmp(z,"-header")==0 ){
-      data.showHeader = 1;
-    }else if( strcmp(z,"-noheader")==0 ){
-      data.showHeader = 0;
-    }else if( strcmp(z,"-echo")==0 ){
-      data.echoOn = 1;
-    }else if( strcmp(z,"-eqp")==0 ){
-      data.autoEQP = 1;
-    }else if( strcmp(z,"-stats")==0 ){
-      data.statsOn = 1;
-    }else if( strcmp(z,"-scanstats")==0 ){
-      data.scanstatsOn = 1;
-    }else if( strcmp(z,"-backslash")==0 ){
-      /* Undocumented command-line option: -backslash
-      ** Causes C-style backslash escapes to be evaluated in SQL statements
-      ** prior to sending the SQL into SQLite.  Useful for injecting
-      ** crazy bytes in the middle of SQL statements for testing and debugging.
-      */
-      data.backslashOn = 1;
-    }else if( strcmp(z,"-bail")==0 ){
-      bail_on_error = 1;
-    }else if( strcmp(z,"-version")==0 ){
-      printf("%s %s\n", sqlite3_libversion(), sqlite3_sourceid());
-      return 0;
-    }else if( strcmp(z,"-interactive")==0 ){
-      stdin_is_interactive = 1;
-    }else if( strcmp(z,"-batch")==0 ){
-      stdin_is_interactive = 0;
-    }else if( strcmp(z,"-heap")==0 ){
-      i++;
-    }else if( strcmp(z,"-scratch")==0 ){
-      i+=2;
-    }else if( strcmp(z,"-pagecache")==0 ){
-      i+=2;
-    }else if( strcmp(z,"-lookaside")==0 ){
-      i+=2;
-    }else if( strcmp(z,"-mmap")==0 ){
-      i++;
-    }else if( strcmp(z,"-vfs")==0 ){
-      i++;
-#ifdef SQLITE_ENABLE_VFSTRACE
-    }else if( strcmp(z,"-vfstrace")==0 ){
-      i++;
-#endif
-#ifdef SQLITE_ENABLE_MULTIPLEX
-    }else if( strcmp(z,"-multiplex")==0 ){
-      i++;
-#endif
-    }else if( strcmp(z,"-help")==0 ){
-      usage(1);
-    }else if( strcmp(z,"-cmd")==0 ){
-      /* Run commands that follow -cmd first and separately from commands
-      ** that simply appear on the command-line.  This seems goofy.  It would
-      ** be better if all commands ran in the order that they appear.  But
-      ** we retain the goofy behavior for historical compatibility. */
-      if( i==argc-1 ) break;
-      z = cmdline_option_value(argc,argv,++i);
-      if( z[0]=='.' ){
-        rc = do_meta_command(z, &data);
-        if( rc && bail_on_error ) return rc==2 ? 0 : rc;
-      }else{
-        open_db(&data, 0);
-        rc = shell_exec(data.db, z, shell_callback, &data, &zErrMsg);
-        if( zErrMsg!=0 ){
-          utf8_printf(stderr,"Error: %s\n", zErrMsg);
-          if( bail_on_error ) return rc!=0 ? rc : 1;
-        }else if( rc!=0 ){
-          utf8_printf(stderr,"Error: unable to process SQL \"%s\"\n", z);
-          if( bail_on_error ) return rc;
-        }
-      }
-    }else{
-      utf8_printf(stderr,"%s: Error: unknown option: %s\n", Argv0, z);
-      raw_printf(stderr,"Use -help for a list of options.\n");
-      return 1;
-    }
-  }
-
-  if( !readStdin ){
-    /* Run all arguments that do not begin with '-' as if they were separate
-    ** command-line inputs, except for the argToSkip argument which contains
-    ** the database filename.
-    */
-    for(i=0; i<nCmd; i++){
-      if( azCmd[i][0]=='.' ){
-        rc = do_meta_command(azCmd[i], &data);
-        if( rc ) return rc==2 ? 0 : rc;
-      }else{
-        open_db(&data, 0);
-        rc = shell_exec(data.db, azCmd[i], shell_callback, &data, &zErrMsg);
-        if( zErrMsg!=0 ){
-          utf8_printf(stderr,"Error: %s\n", zErrMsg);
-          return rc!=0 ? rc : 1;
-        }else if( rc!=0 ){
-          utf8_printf(stderr,"Error: unable to process SQL: %s\n", azCmd[i]);
-          return rc;
-        }
-      }
-    }
-    free(azCmd);
-  }else{
-    /* Run commands received from standard input
-    */
-    if( stdin_is_interactive ){
-      char *zHome;
-      char *zHistory = 0;
-      int nHistory;
-      printf(
-        "SQLite version %s %.19s\n" /*extra-version-info*/
-        "Enter \".help\" for usage hints.\n",
-        sqlite3_libversion(), sqlite3_sourceid()
-      );
-      if( warnInmemoryDb ){
-        printf("Connected to a ");
-        printBold("transient in-memory database");
-        printf(".\nUse \".open FILENAME\" to reopen on a "
-               "persistent database.\n");
-      }
-      zHome = find_home_dir();
-      if( zHome ){
-        nHistory = strlen30(zHome) + 20;
-        if( (zHistory = malloc(nHistory))!=0 ){
-          sqlite3_snprintf(nHistory, zHistory,"%s/.sqlite_history", zHome);
-        }
-      }
-      if( zHistory ){ shell_read_history(zHistory); }
-      rc = process_input(&data, 0);
-      if( zHistory ){
-        shell_stifle_history(100);
-        shell_write_history(zHistory);
-        free(zHistory);
-      }
-    }else{
-      rc = process_input(&data, stdin);
-    }
-  }
-  set_table_name(&data, 0);
-  if( data.db ){
-    sqlite3_close(data.db);
-  }
-  sqlite3_free(data.zFreeOnClose); 
-  return rc;
-}
diff --git a/src/3rdparty/sqlite/sqlite3.c b/src/3rdparty/sqlite/sqlite3.c
index b39772604c2..123c65e3965 100644
--- a/src/3rdparty/sqlite/sqlite3.c
+++ b/src/3rdparty/sqlite/sqlite3.c
@@ -1,6 +1,6 @@
 /******************************************************************************
 ** This file is an amalgamation of many separate C source files from SQLite
-** version 3.10.2.  By combining all the individual C code files into this 
+** version 3.11.1.  By combining all the individual C code files into this 
 ** single large file, the entire code can be compiled as a single translation
 ** unit.  This allows many compilers to do optimizations that would not be
 ** possible if the files were compiled separately.  Performance improvements
@@ -121,6 +121,9 @@
 #else
 /* This is not VxWorks. */
 #define OS_VXWORKS 0
+#define HAVE_FCHOWN 1
+#define HAVE_READLINK 1
+#define HAVE_LSTAT 1
 #endif /* defined(_WRS_KERNEL) */
 
 /************** End of vxworks.h *********************************************/
@@ -325,9 +328,9 @@ extern "C" {
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
 ** [sqlite_version()] and [sqlite_source_id()].
 */
-#define SQLITE_VERSION        "3.10.2"
-#define SQLITE_VERSION_NUMBER 3010002
-#define SQLITE_SOURCE_ID      "2016-01-20 15:27:19 17efb4209f97fb4971656086b138599a91a75ff9"
+#define SQLITE_VERSION        "3.11.1"
+#define SQLITE_VERSION_NUMBER 3011001
+#define SQLITE_SOURCE_ID      "2016-03-03 16:17:53 f047920ce16971e573bc6ec9a48b118c9de2b3a7"
 
 /*
 ** CAPI3REF: Run-Time Library Version Numbers
@@ -561,7 +564,7 @@ typedef int (*sqlite3_callback)(void*,int,char**, char**);
 ** from [sqlite3_malloc()] and passed back through the 5th parameter.
 ** To avoid memory leaks, the application should invoke [sqlite3_free()]
 ** on error message strings returned through the 5th parameter of
-** of sqlite3_exec() after the error message string is no longer needed.
+** sqlite3_exec() after the error message string is no longer needed.
 ** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors
 ** occur, then sqlite3_exec() sets the pointer in its 5th parameter to
 ** NULL before returning.
@@ -5911,7 +5914,7 @@ struct sqlite3_index_info {
   /* Inputs */
   int nConstraint;           /* Number of entries in aConstraint */
   struct sqlite3_index_constraint {
-     int iColumn;              /* Column on left-hand side of constraint */
+     int iColumn;              /* Column constrained.  -1 for ROWID */
      unsigned char op;         /* Constraint operator */
      unsigned char usable;     /* True if this constraint is usable */
      int iTermOffset;          /* Used internally - xBestIndex should ignore */
@@ -8407,6 +8410,9 @@ struct Fts5PhraseIter {
 **   an OOM condition or IO error), an appropriate SQLite error code is 
 **   returned.
 **
+**   This function may be quite inefficient if used with an FTS5 table
+**   created with the "columnsize=0" option.
+**
 ** xColumnText:
 **   This function attempts to retrieve the text of column iCol of the
 **   current document. If successful, (*pz) is set to point to a buffer
@@ -8427,15 +8433,29 @@ struct Fts5PhraseIter {
 **   the query within the current row. Return SQLITE_OK if successful, or
 **   an error code (i.e. SQLITE_NOMEM) if an error occurs.
 **
+**   This API can be quite slow if used with an FTS5 table created with the
+**   "detail=none" or "detail=column" option. If the FTS5 table is created 
+**   with either "detail=none" or "detail=column" and "content=" option 
+**   (i.e. if it is a contentless table), then this API always returns 0.
+**
 ** xInst:
 **   Query for the details of phrase match iIdx within the current row.
 **   Phrase matches are numbered starting from zero, so the iIdx argument
 **   should be greater than or equal to zero and smaller than the value
 **   output by xInstCount().
 **
+**   Usually, output parameter *piPhrase is set to the phrase number, *piCol
+**   to the column in which it occurs and *piOff the token offset of the
+**   first token of the phrase. The exception is if the table was created
+**   with the offsets=0 option specified. In this case *piOff is always
+**   set to -1.
+**
 **   Returns SQLITE_OK if successful, or an error code (i.e. SQLITE_NOMEM) 
 **   if an error occurs.
 **
+**   This API can be quite slow if used with an FTS5 table created with the
+**   "detail=none" or "detail=column" option. 
+**
 ** xRowid:
 **   Returns the rowid of the current row.
 **
@@ -8519,7 +8539,7 @@ struct Fts5PhraseIter {
 **       Fts5PhraseIter iter;
 **       int iCol, iOff;
 **       for(pApi->xPhraseFirst(pFts, iPhrase, &iter, &iCol, &iOff);
-**           iOff>=0;
+**           iCol>=0;
 **           pApi->xPhraseNext(pFts, &iter, &iCol, &iOff)
 **       ){
 **         // An instance of phrase iPhrase at offset iOff of column iCol
@@ -8527,13 +8547,51 @@ struct Fts5PhraseIter {
 **
 **   The Fts5PhraseIter structure is defined above. Applications should not
 **   modify this structure directly - it should only be used as shown above
-**   with the xPhraseFirst() and xPhraseNext() API methods.
+**   with the xPhraseFirst() and xPhraseNext() API methods (and by
+**   xPhraseFirstColumn() and xPhraseNextColumn() as illustrated below).
+**
+**   This API can be quite slow if used with an FTS5 table created with the
+**   "detail=none" or "detail=column" option. If the FTS5 table is created 
+**   with either "detail=none" or "detail=column" and "content=" option 
+**   (i.e. if it is a contentless table), then this API always iterates
+**   through an empty set (all calls to xPhraseFirst() set iCol to -1).
 **
 ** xPhraseNext()
 **   See xPhraseFirst above.
+**
+** xPhraseFirstColumn()
+**   This function and xPhraseNextColumn() are similar to the xPhraseFirst()
+**   and xPhraseNext() APIs described above. The difference is that instead
+**   of iterating through all instances of a phrase in the current row, these
+**   APIs are used to iterate through the set of columns in the current row
+**   that contain one or more instances of a specified phrase. For example:
+**
+**       Fts5PhraseIter iter;
+**       int iCol;
+**       for(pApi->xPhraseFirstColumn(pFts, iPhrase, &iter, &iCol);
+**           iCol>=0;
+**           pApi->xPhraseNextColumn(pFts, &iter, &iCol)
+**       ){
+**         // Column iCol contains at least one instance of phrase iPhrase
+**       }
+**
+**   This API can be quite slow if used with an FTS5 table created with the
+**   "detail=none" option. If the FTS5 table is created with either 
+**   "detail=none" "content=" option (i.e. if it is a contentless table), 
+**   then this API always iterates through an empty set (all calls to 
+**   xPhraseFirstColumn() set iCol to -1).
+**
+**   The information accessed using this API and its companion
+**   xPhraseFirstColumn() may also be obtained using xPhraseFirst/xPhraseNext
+**   (or xInst/xInstCount). The chief advantage of this API is that it is
+**   significantly more efficient than those alternatives when used with
+**   "detail=column" tables.  
+**
+** xPhraseNextColumn()
+**   See xPhraseFirstColumn above.
 */
 struct Fts5ExtensionApi {
-  int iVersion;                   /* Currently always set to 1 */
+  int iVersion;                   /* Currently always set to 3 */
 
   void *(*xUserData)(Fts5Context*);
 
@@ -8563,8 +8621,11 @@ struct Fts5ExtensionApi {
   int (*xSetAuxdata)(Fts5Context*, void *pAux, void(*xDelete)(void*));
   void *(*xGetAuxdata)(Fts5Context*, int bClear);
 
-  void (*xPhraseFirst)(Fts5Context*, int iPhrase, Fts5PhraseIter*, int*, int*);
+  int (*xPhraseFirst)(Fts5Context*, int iPhrase, Fts5PhraseIter*, int*, int*);
   void (*xPhraseNext)(Fts5Context*, Fts5PhraseIter*, int *piCol, int *piOff);
+
+  int (*xPhraseFirstColumn)(Fts5Context*, int iPhrase, Fts5PhraseIter*, int*);
+  void (*xPhraseNextColumn)(Fts5Context*, Fts5PhraseIter*, int *piCol);
 };
 
 /* 
@@ -9348,6 +9409,21 @@ SQLITE_PRIVATE   void sqlite3Coverage(int);
 # define NEVER(X)       (X)
 #endif
 
+/*
+** Some malloc failures are only possible if SQLITE_TEST_REALLOC_STRESS is
+** defined.  We need to defend against those failures when testing with
+** SQLITE_TEST_REALLOC_STRESS, but we don't want the unreachable branches
+** during a normal build.  The following macro can be used to disable tests
+** that are always false except when SQLITE_TEST_REALLOC_STRESS is set.
+*/
+#if defined(SQLITE_TEST_REALLOC_STRESS)
+# define ONLY_IF_REALLOC_STRESS(X)  (X)
+#elif !defined(NDEBUG)
+# define ONLY_IF_REALLOC_STRESS(X)  ((X)?(assert(0),1):0)
+#else
+# define ONLY_IF_REALLOC_STRESS(X)  (0)
+#endif
+
 /*
 ** Declarations used for tracing the operating system interfaces.
 */
@@ -9984,10 +10060,6 @@ typedef INT16_TYPE LogEst;
 */
 #ifdef __APPLE__
 # include <TargetConditionals.h>
-# if TARGET_OS_IPHONE
-#   undef SQLITE_MAX_MMAP_SIZE
-#   define SQLITE_MAX_MMAP_SIZE 0
-# endif
 #endif
 #ifndef SQLITE_MAX_MMAP_SIZE
 # if defined(__linux__) \
@@ -10399,14 +10471,24 @@ SQLITE_PRIVATE int sqlite3BtreeNewDb(Btree *p);
 ** Flags passed as the third argument to sqlite3BtreeCursor().
 **
 ** For read-only cursors the wrFlag argument is always zero. For read-write
-** cursors it may be set to either (BTREE_WRCSR|BTREE_FORDELETE) or
-** (BTREE_WRCSR). If the BTREE_FORDELETE flag is set, then the cursor will
+** cursors it may be set to either (BTREE_WRCSR|BTREE_FORDELETE) or just
+** (BTREE_WRCSR). If the BTREE_FORDELETE bit is set, then the cursor will
 ** only be used by SQLite for the following:
 **
-**   * to seek to and delete specific entries, and/or
+**   * to seek to and then delete specific entries, and/or
 **
 **   * to read values that will be used to create keys that other
 **     BTREE_FORDELETE cursors will seek to and delete.
+**
+** The BTREE_FORDELETE flag is an optimization hint.  It is not used by
+** by this, the native b-tree engine of SQLite, but it is available to
+** alternative storage engines that might be substituted in place of this
+** b-tree system.  For alternative storage engines in which a delete of
+** the main table row automatically deletes corresponding index rows,
+** the FORDELETE flag hint allows those alternative storage engines to
+** skip a lot of work.  Namely:  FORDELETE cursors may treat all SEEK
+** and DELETE operations as no-ops, and any READ operation against a
+** FORDELETE cursor may return a null row: 0x01 0x00.
 */
 #define BTREE_WRCSR     0x00000004     /* read-write cursor */
 #define BTREE_FORDELETE 0x00000008     /* Cursor is for seek/delete only */
@@ -10435,7 +10517,12 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(
 );
 SQLITE_PRIVATE int sqlite3BtreeCursorHasMoved(BtCursor*);
 SQLITE_PRIVATE int sqlite3BtreeCursorRestore(BtCursor*, int*);
-SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*, int);
+SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor*, u8 flags);
+
+/* Allowed flags for the 2nd argument to sqlite3BtreeDelete() */
+#define BTREE_SAVEPOSITION 0x02  /* Leave cursor pointing at NEXT or PREV */
+#define BTREE_AUXDELETE    0x04  /* not the primary delete operation */
+
 SQLITE_PRIVATE int sqlite3BtreeInsert(BtCursor*, const void *pKey, i64 nKey,
                                   const void *pData, int nData,
                                   int nZero, int bias, int seekResult);
@@ -10487,15 +10574,17 @@ SQLITE_PRIVATE   int sqlite3BtreeCheckpoint(Btree*, int, int *, int *);
 #ifndef SQLITE_OMIT_SHARED_CACHE
 SQLITE_PRIVATE   void sqlite3BtreeEnter(Btree*);
 SQLITE_PRIVATE   void sqlite3BtreeEnterAll(sqlite3*);
+SQLITE_PRIVATE   int sqlite3BtreeSharable(Btree*);
+SQLITE_PRIVATE   void sqlite3BtreeEnterCursor(BtCursor*);
 #else
 # define sqlite3BtreeEnter(X) 
 # define sqlite3BtreeEnterAll(X)
+# define sqlite3BtreeSharable(X) 0
+# define sqlite3BtreeEnterCursor(X)
 #endif
 
 #if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE
-SQLITE_PRIVATE   int sqlite3BtreeSharable(Btree*);
 SQLITE_PRIVATE   void sqlite3BtreeLeave(Btree*);
-SQLITE_PRIVATE   void sqlite3BtreeEnterCursor(BtCursor*);
 SQLITE_PRIVATE   void sqlite3BtreeLeaveCursor(BtCursor*);
 SQLITE_PRIVATE   void sqlite3BtreeLeaveAll(sqlite3*);
 #ifndef NDEBUG
@@ -10506,9 +10595,7 @@ SQLITE_PRIVATE   int sqlite3SchemaMutexHeld(sqlite3*,int,Schema*);
 #endif
 #else
 
-# define sqlite3BtreeSharable(X) 0
 # define sqlite3BtreeLeave(X)
-# define sqlite3BtreeEnterCursor(X)
 # define sqlite3BtreeLeaveCursor(X)
 # define sqlite3BtreeLeaveAll(X)
 
@@ -10693,81 +10780,82 @@ typedef struct VdbeOpList VdbeOpList;
 /************** Begin file opcodes.h *****************************************/
 /* Automatically generated.  Do not edit */
 /* See the tool/mkopcodeh.tcl script for details */
-#define OP_Savepoint       1
-#define OP_AutoCommit      2
-#define OP_Transaction     3
-#define OP_SorterNext      4
-#define OP_PrevIfOpen      5
-#define OP_NextIfOpen      6
-#define OP_Prev            7
-#define OP_Next            8
-#define OP_Checkpoint      9
-#define OP_JournalMode    10
-#define OP_Vacuum         11
-#define OP_VFilter        12 /* synopsis: iplan=r[P3] zplan='P4'           */
-#define OP_VUpdate        13 /* synopsis: data=r[P3@P2]                    */
-#define OP_Goto           14
-#define OP_Gosub          15
-#define OP_Return         16
-#define OP_InitCoroutine  17
-#define OP_EndCoroutine   18
+#define OP_Savepoint       0
+#define OP_AutoCommit      1
+#define OP_Transaction     2
+#define OP_SorterNext      3
+#define OP_PrevIfOpen      4
+#define OP_NextIfOpen      5
+#define OP_Prev            6
+#define OP_Next            7
+#define OP_Checkpoint      8
+#define OP_JournalMode     9
+#define OP_Vacuum         10
+#define OP_VFilter        11 /* synopsis: iplan=r[P3] zplan='P4'           */
+#define OP_VUpdate        12 /* synopsis: data=r[P3@P2]                    */
+#define OP_Goto           13
+#define OP_Gosub          14
+#define OP_Return         15
+#define OP_InitCoroutine  16
+#define OP_EndCoroutine   17
+#define OP_Yield          18
 #define OP_Not            19 /* same as TK_NOT, synopsis: r[P2]= !r[P1]    */
-#define OP_Yield          20
-#define OP_HaltIfNull     21 /* synopsis: if r[P3]=null halt               */
-#define OP_Halt           22
-#define OP_Integer        23 /* synopsis: r[P2]=P1                         */
-#define OP_Int64          24 /* synopsis: r[P2]=P4                         */
-#define OP_String         25 /* synopsis: r[P2]='P4' (len=P1)              */
-#define OP_Null           26 /* synopsis: r[P2..P3]=NULL                   */
-#define OP_SoftNull       27 /* synopsis: r[P1]=NULL                       */
-#define OP_Blob           28 /* synopsis: r[P2]=P4 (len=P1)                */
-#define OP_Variable       29 /* synopsis: r[P2]=parameter(P1,P4)           */
-#define OP_Move           30 /* synopsis: r[P2@P3]=r[P1@P3]                */
-#define OP_Copy           31 /* synopsis: r[P2@P3+1]=r[P1@P3+1]            */
-#define OP_SCopy          32 /* synopsis: r[P2]=r[P1]                      */
-#define OP_IntCopy        33 /* synopsis: r[P2]=r[P1]                      */
-#define OP_ResultRow      34 /* synopsis: output=r[P1@P2]                  */
-#define OP_CollSeq        35
-#define OP_Function0      36 /* synopsis: r[P3]=func(r[P2@P5])             */
-#define OP_Function       37 /* synopsis: r[P3]=func(r[P2@P5])             */
-#define OP_AddImm         38 /* synopsis: r[P1]=r[P1]+P2                   */
-#define OP_MustBeInt      39
-#define OP_RealAffinity   40
-#define OP_Cast           41 /* synopsis: affinity(r[P1])                  */
-#define OP_Permutation    42
-#define OP_Compare        43 /* synopsis: r[P1@P3] <-> r[P2@P3]            */
-#define OP_Jump           44
-#define OP_Once           45
-#define OP_If             46
-#define OP_IfNot          47
-#define OP_Column         48 /* synopsis: r[P3]=PX                         */
-#define OP_Affinity       49 /* synopsis: affinity(r[P1@P2])               */
-#define OP_MakeRecord     50 /* synopsis: r[P3]=mkrec(r[P1@P2])            */
-#define OP_Count          51 /* synopsis: r[P2]=count()                    */
-#define OP_ReadCookie     52
-#define OP_SetCookie      53
-#define OP_ReopenIdx      54 /* synopsis: root=P2 iDb=P3                   */
-#define OP_OpenRead       55 /* synopsis: root=P2 iDb=P3                   */
-#define OP_OpenWrite      56 /* synopsis: root=P2 iDb=P3                   */
-#define OP_OpenAutoindex  57 /* synopsis: nColumn=P2                       */
-#define OP_OpenEphemeral  58 /* synopsis: nColumn=P2                       */
-#define OP_SorterOpen     59
-#define OP_SequenceTest   60 /* synopsis: if( cursor[P1].ctr++ ) pc = P2   */
-#define OP_OpenPseudo     61 /* synopsis: P3 columns in r[P2]              */
-#define OP_Close          62
-#define OP_ColumnsUsed    63
-#define OP_SeekLT         64 /* synopsis: key=r[P3@P4]                     */
-#define OP_SeekLE         65 /* synopsis: key=r[P3@P4]                     */
-#define OP_SeekGE         66 /* synopsis: key=r[P3@P4]                     */
-#define OP_SeekGT         67 /* synopsis: key=r[P3@P4]                     */
-#define OP_Seek           68 /* synopsis: intkey=r[P2]                     */
-#define OP_NoConflict     69 /* synopsis: key=r[P3@P4]                     */
-#define OP_NotFound       70 /* synopsis: key=r[P3@P4]                     */
+#define OP_HaltIfNull     20 /* synopsis: if r[P3]=null halt               */
+#define OP_Halt           21
+#define OP_Integer        22 /* synopsis: r[P2]=P1                         */
+#define OP_Int64          23 /* synopsis: r[P2]=P4                         */
+#define OP_String         24 /* synopsis: r[P2]='P4' (len=P1)              */
+#define OP_Null           25 /* synopsis: r[P2..P3]=NULL                   */
+#define OP_SoftNull       26 /* synopsis: r[P1]=NULL                       */
+#define OP_Blob           27 /* synopsis: r[P2]=P4 (len=P1)                */
+#define OP_Variable       28 /* synopsis: r[P2]=parameter(P1,P4)           */
+#define OP_Move           29 /* synopsis: r[P2@P3]=r[P1@P3]                */
+#define OP_Copy           30 /* synopsis: r[P2@P3+1]=r[P1@P3+1]            */
+#define OP_SCopy          31 /* synopsis: r[P2]=r[P1]                      */
+#define OP_IntCopy        32 /* synopsis: r[P2]=r[P1]                      */
+#define OP_ResultRow      33 /* synopsis: output=r[P1@P2]                  */
+#define OP_CollSeq        34
+#define OP_Function0      35 /* synopsis: r[P3]=func(r[P2@P5])             */
+#define OP_Function       36 /* synopsis: r[P3]=func(r[P2@P5])             */
+#define OP_AddImm         37 /* synopsis: r[P1]=r[P1]+P2                   */
+#define OP_MustBeInt      38
+#define OP_RealAffinity   39
+#define OP_Cast           40 /* synopsis: affinity(r[P1])                  */
+#define OP_Permutation    41
+#define OP_Compare        42 /* synopsis: r[P1@P3] <-> r[P2@P3]            */
+#define OP_Jump           43
+#define OP_Once           44
+#define OP_If             45
+#define OP_IfNot          46
+#define OP_Column         47 /* synopsis: r[P3]=PX                         */
+#define OP_Affinity       48 /* synopsis: affinity(r[P1@P2])               */
+#define OP_MakeRecord     49 /* synopsis: r[P3]=mkrec(r[P1@P2])            */
+#define OP_Count          50 /* synopsis: r[P2]=count()                    */
+#define OP_ReadCookie     51
+#define OP_SetCookie      52
+#define OP_ReopenIdx      53 /* synopsis: root=P2 iDb=P3                   */
+#define OP_OpenRead       54 /* synopsis: root=P2 iDb=P3                   */
+#define OP_OpenWrite      55 /* synopsis: root=P2 iDb=P3                   */
+#define OP_OpenAutoindex  56 /* synopsis: nColumn=P2                       */
+#define OP_OpenEphemeral  57 /* synopsis: nColumn=P2                       */
+#define OP_SorterOpen     58
+#define OP_SequenceTest   59 /* synopsis: if( cursor[P1].ctr++ ) pc = P2   */
+#define OP_OpenPseudo     60 /* synopsis: P3 columns in r[P2]              */
+#define OP_Close          61
+#define OP_ColumnsUsed    62
+#define OP_SeekLT         63 /* synopsis: key=r[P3@P4]                     */
+#define OP_SeekLE         64 /* synopsis: key=r[P3@P4]                     */
+#define OP_SeekGE         65 /* synopsis: key=r[P3@P4]                     */
+#define OP_SeekGT         66 /* synopsis: key=r[P3@P4]                     */
+#define OP_NoConflict     67 /* synopsis: key=r[P3@P4]                     */
+#define OP_NotFound       68 /* synopsis: key=r[P3@P4]                     */
+#define OP_Found          69 /* synopsis: key=r[P3@P4]                     */
+#define OP_NotExists      70 /* synopsis: intkey=r[P3]                     */
 #define OP_Or             71 /* same as TK_OR, synopsis: r[P3]=(r[P1] || r[P2]) */
 #define OP_And            72 /* same as TK_AND, synopsis: r[P3]=(r[P1] && r[P2]) */
-#define OP_Found          73 /* synopsis: key=r[P3@P4]                     */
-#define OP_NotExists      74 /* synopsis: intkey=r[P3]                     */
-#define OP_Sequence       75 /* synopsis: r[P2]=cursor[P1].ctr++           */
+#define OP_Sequence       73 /* synopsis: r[P2]=cursor[P1].ctr++           */
+#define OP_NewRowid       74 /* synopsis: r[P2]=rowid                      */
+#define OP_Insert         75 /* synopsis: intkey=r[P3] data=r[P2]          */
 #define OP_IsNull         76 /* same as TK_ISNULL, synopsis: if r[P1]==NULL goto P2 */
 #define OP_NotNull        77 /* same as TK_NOTNULL, synopsis: if r[P1]!=NULL goto P2 */
 #define OP_Ne             78 /* same as TK_NE, synopsis: if r[P1]!=r[P3] goto P2 */
@@ -10776,7 +10864,7 @@ typedef struct VdbeOpList VdbeOpList;
 #define OP_Le             81 /* same as TK_LE, synopsis: if r[P1]<=r[P3] goto P2 */
 #define OP_Lt             82 /* same as TK_LT, synopsis: if r[P1]<r[P3] goto P2 */
 #define OP_Ge             83 /* same as TK_GE, synopsis: if r[P1]>=r[P3] goto P2 */
-#define OP_NewRowid       84 /* synopsis: r[P2]=rowid                      */
+#define OP_InsertInt      84 /* synopsis: intkey=P3 data=r[P2]             */
 #define OP_BitAnd         85 /* same as TK_BITAND, synopsis: r[P3]=r[P1]&r[P2] */
 #define OP_BitOr          86 /* same as TK_BITOR, synopsis: r[P3]=r[P1]|r[P2] */
 #define OP_ShiftLeft      87 /* same as TK_LSHIFT, synopsis: r[P3]=r[P2]<<r[P1] */
@@ -10787,107 +10875,106 @@ typedef struct VdbeOpList VdbeOpList;
 #define OP_Divide         92 /* same as TK_SLASH, synopsis: r[P3]=r[P2]/r[P1] */
 #define OP_Remainder      93 /* same as TK_REM, synopsis: r[P3]=r[P2]%r[P1] */
 #define OP_Concat         94 /* same as TK_CONCAT, synopsis: r[P3]=r[P2]+r[P1] */
-#define OP_Insert         95 /* synopsis: intkey=r[P3] data=r[P2]          */
+#define OP_Delete         95
 #define OP_BitNot         96 /* same as TK_BITNOT, synopsis: r[P1]= ~r[P1] */
 #define OP_String8        97 /* same as TK_STRING, synopsis: r[P2]='P4'    */
-#define OP_InsertInt      98 /* synopsis: intkey=P3 data=r[P2]             */
-#define OP_Delete         99
-#define OP_ResetCount    100
-#define OP_SorterCompare 101 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */
-#define OP_SorterData    102 /* synopsis: r[P2]=data                       */
-#define OP_RowKey        103 /* synopsis: r[P2]=key                        */
-#define OP_RowData       104 /* synopsis: r[P2]=data                       */
-#define OP_Rowid         105 /* synopsis: r[P2]=rowid                      */
-#define OP_NullRow       106
-#define OP_Last          107
-#define OP_SorterSort    108
-#define OP_Sort          109
-#define OP_Rewind        110
-#define OP_SorterInsert  111
-#define OP_IdxInsert     112 /* synopsis: key=r[P2]                        */
-#define OP_IdxDelete     113 /* synopsis: key=r[P2@P3]                     */
-#define OP_IdxRowid      114 /* synopsis: r[P2]=rowid                      */
-#define OP_IdxLE         115 /* synopsis: key=r[P3@P4]                     */
-#define OP_IdxGT         116 /* synopsis: key=r[P3@P4]                     */
-#define OP_IdxLT         117 /* synopsis: key=r[P3@P4]                     */
-#define OP_IdxGE         118 /* synopsis: key=r[P3@P4]                     */
-#define OP_Destroy       119
-#define OP_Clear         120
-#define OP_ResetSorter   121
-#define OP_CreateIndex   122 /* synopsis: r[P2]=root iDb=P1                */
-#define OP_CreateTable   123 /* synopsis: r[P2]=root iDb=P1                */
-#define OP_ParseSchema   124
-#define OP_LoadAnalysis  125
-#define OP_DropTable     126
-#define OP_DropIndex     127
-#define OP_DropTrigger   128
-#define OP_IntegrityCk   129
-#define OP_RowSetAdd     130 /* synopsis: rowset(P1)=r[P2]                 */
-#define OP_RowSetRead    131 /* synopsis: r[P3]=rowset(P1)                 */
-#define OP_RowSetTest    132 /* synopsis: if r[P3] in rowset(P1) goto P2   */
+#define OP_ResetCount     98
+#define OP_SorterCompare  99 /* synopsis: if key(P1)!=trim(r[P3],P4) goto P2 */
+#define OP_SorterData    100 /* synopsis: r[P2]=data                       */
+#define OP_RowKey        101 /* synopsis: r[P2]=key                        */
+#define OP_RowData       102 /* synopsis: r[P2]=data                       */
+#define OP_Rowid         103 /* synopsis: r[P2]=rowid                      */
+#define OP_NullRow       104
+#define OP_Last          105
+#define OP_SorterSort    106
+#define OP_Sort          107
+#define OP_Rewind        108
+#define OP_SorterInsert  109
+#define OP_IdxInsert     110 /* synopsis: key=r[P2]                        */
+#define OP_IdxDelete     111 /* synopsis: key=r[P2@P3]                     */
+#define OP_Seek          112 /* synopsis: Move P3 to P1.rowid              */
+#define OP_IdxRowid      113 /* synopsis: r[P2]=rowid                      */
+#define OP_IdxLE         114 /* synopsis: key=r[P3@P4]                     */
+#define OP_IdxGT         115 /* synopsis: key=r[P3@P4]                     */
+#define OP_IdxLT         116 /* synopsis: key=r[P3@P4]                     */
+#define OP_IdxGE         117 /* synopsis: key=r[P3@P4]                     */
+#define OP_Destroy       118
+#define OP_Clear         119
+#define OP_ResetSorter   120
+#define OP_CreateIndex   121 /* synopsis: r[P2]=root iDb=P1                */
+#define OP_CreateTable   122 /* synopsis: r[P2]=root iDb=P1                */
+#define OP_ParseSchema   123
+#define OP_LoadAnalysis  124
+#define OP_DropTable     125
+#define OP_DropIndex     126
+#define OP_DropTrigger   127
+#define OP_IntegrityCk   128
+#define OP_RowSetAdd     129 /* synopsis: rowset(P1)=r[P2]                 */
+#define OP_RowSetRead    130 /* synopsis: r[P3]=rowset(P1)                 */
+#define OP_RowSetTest    131 /* synopsis: if r[P3] in rowset(P1) goto P2   */
+#define OP_Program       132
 #define OP_Real          133 /* same as TK_FLOAT, synopsis: r[P2]=P4       */
-#define OP_Program       134
-#define OP_Param         135
-#define OP_FkCounter     136 /* synopsis: fkctr[P1]+=P2                    */
-#define OP_FkIfZero      137 /* synopsis: if fkctr[P1]==0 goto P2          */
-#define OP_MemMax        138 /* synopsis: r[P1]=max(r[P1],r[P2])           */
-#define OP_IfPos         139 /* synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */
-#define OP_SetIfNotPos   140 /* synopsis: if r[P1]<=0 then r[P2]=P3        */
-#define OP_IfNotZero     141 /* synopsis: if r[P1]!=0 then r[P1]-=P3, goto P2 */
-#define OP_DecrJumpZero  142 /* synopsis: if (--r[P1])==0 goto P2          */
-#define OP_JumpZeroIncr  143 /* synopsis: if (r[P1]++)==0 ) goto P2        */
-#define OP_AggStep0      144 /* synopsis: accum=r[P3] step(r[P2@P5])       */
-#define OP_AggStep       145 /* synopsis: accum=r[P3] step(r[P2@P5])       */
-#define OP_AggFinal      146 /* synopsis: accum=r[P1] N=P2                 */
-#define OP_IncrVacuum    147
-#define OP_Expire        148
-#define OP_TableLock     149 /* synopsis: iDb=P1 root=P2 write=P3          */
-#define OP_VBegin        150
-#define OP_VCreate       151
-#define OP_VDestroy      152
-#define OP_VOpen         153
-#define OP_VColumn       154 /* synopsis: r[P3]=vcolumn(P2)                */
-#define OP_VNext         155
-#define OP_VRename       156
-#define OP_Pagecount     157
-#define OP_MaxPgcnt      158
-#define OP_Init          159 /* synopsis: Start at P2                      */
-#define OP_CursorHint    160
-#define OP_Noop          161
-#define OP_Explain       162
+#define OP_Param         134
+#define OP_FkCounter     135 /* synopsis: fkctr[P1]+=P2                    */
+#define OP_FkIfZero      136 /* synopsis: if fkctr[P1]==0 goto P2          */
+#define OP_MemMax        137 /* synopsis: r[P1]=max(r[P1],r[P2])           */
+#define OP_IfPos         138 /* synopsis: if r[P1]>0 then r[P1]-=P3, goto P2 */
+#define OP_OffsetLimit   139 /* synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1) */
+#define OP_IfNotZero     140 /* synopsis: if r[P1]!=0 then r[P1]-=P3, goto P2 */
+#define OP_DecrJumpZero  141 /* synopsis: if (--r[P1])==0 goto P2          */
+#define OP_JumpZeroIncr  142 /* synopsis: if (r[P1]++)==0 ) goto P2        */
+#define OP_AggStep0      143 /* synopsis: accum=r[P3] step(r[P2@P5])       */
+#define OP_AggStep       144 /* synopsis: accum=r[P3] step(r[P2@P5])       */
+#define OP_AggFinal      145 /* synopsis: accum=r[P1] N=P2                 */
+#define OP_IncrVacuum    146
+#define OP_Expire        147
+#define OP_TableLock     148 /* synopsis: iDb=P1 root=P2 write=P3          */
+#define OP_VBegin        149
+#define OP_VCreate       150
+#define OP_VDestroy      151
+#define OP_VOpen         152
+#define OP_VColumn       153 /* synopsis: r[P3]=vcolumn(P2)                */
+#define OP_VNext         154
+#define OP_VRename       155
+#define OP_Pagecount     156
+#define OP_MaxPgcnt      157
+#define OP_Init          158 /* synopsis: Start at P2                      */
+#define OP_CursorHint    159
+#define OP_Noop          160
+#define OP_Explain       161
 
 /* Properties such as "out2" or "jump" that are specified in
 ** comments following the "case" for each opcode in the vdbe.c
 ** are encoded into bitvectors as follows:
 */
-#define OPFLG_JUMP            0x0001  /* jump:  P2 holds jmp target */
-#define OPFLG_IN1             0x0002  /* in1:   P1 is an input */
-#define OPFLG_IN2             0x0004  /* in2:   P2 is an input */
-#define OPFLG_IN3             0x0008  /* in3:   P3 is an input */
-#define OPFLG_OUT2            0x0010  /* out2:  P2 is an output */
-#define OPFLG_OUT3            0x0020  /* out3:  P3 is an output */
+#define OPFLG_JUMP        0x01  /* jump:  P2 holds jmp target */
+#define OPFLG_IN1         0x02  /* in1:   P1 is an input */
+#define OPFLG_IN2         0x04  /* in2:   P2 is an input */
+#define OPFLG_IN3         0x08  /* in3:   P3 is an input */
+#define OPFLG_OUT2        0x10  /* out2:  P2 is an output */
+#define OPFLG_OUT3        0x20  /* out3:  P3 is an output */
 #define OPFLG_INITIALIZER {\
-/*   0 */ 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01,\
-/*   8 */ 0x01, 0x00, 0x10, 0x00, 0x01, 0x00, 0x01, 0x01,\
-/*  16 */ 0x02, 0x01, 0x02, 0x12, 0x03, 0x08, 0x00, 0x10,\
-/*  24 */ 0x10, 0x10, 0x10, 0x00, 0x10, 0x10, 0x00, 0x00,\
-/*  32 */ 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03,\
-/*  40 */ 0x02, 0x02, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03,\
-/*  48 */ 0x00, 0x00, 0x00, 0x10, 0x10, 0x08, 0x00, 0x00,\
-/*  56 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
-/*  64 */ 0x09, 0x09, 0x09, 0x09, 0x04, 0x09, 0x09, 0x26,\
-/*  72 */ 0x26, 0x09, 0x09, 0x10, 0x03, 0x03, 0x0b, 0x0b,\
-/*  80 */ 0x0b, 0x0b, 0x0b, 0x0b, 0x10, 0x26, 0x26, 0x26,\
+/*   0 */ 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01,\
+/*   8 */ 0x00, 0x10, 0x00, 0x01, 0x00, 0x01, 0x01, 0x02,\
+/*  16 */ 0x01, 0x02, 0x03, 0x12, 0x08, 0x00, 0x10, 0x10,\
+/*  24 */ 0x10, 0x10, 0x00, 0x10, 0x10, 0x00, 0x00, 0x10,\
+/*  32 */ 0x10, 0x00, 0x00, 0x00, 0x00, 0x02, 0x03, 0x02,\
+/*  40 */ 0x02, 0x00, 0x00, 0x01, 0x01, 0x03, 0x03, 0x00,\
+/*  48 */ 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,\
+/*  56 */ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x09,\
+/*  64 */ 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x26,\
+/*  72 */ 0x26, 0x10, 0x10, 0x00, 0x03, 0x03, 0x0b, 0x0b,\
+/*  80 */ 0x0b, 0x0b, 0x0b, 0x0b, 0x00, 0x26, 0x26, 0x26,\
 /*  88 */ 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x26, 0x00,\
-/*  96 */ 0x12, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,\
-/* 104 */ 0x00, 0x10, 0x00, 0x01, 0x01, 0x01, 0x01, 0x04,\
-/* 112 */ 0x04, 0x00, 0x10, 0x01, 0x01, 0x01, 0x01, 0x10,\
-/* 120 */ 0x00, 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00,\
-/* 128 */ 0x00, 0x00, 0x06, 0x23, 0x0b, 0x10, 0x01, 0x10,\
-/* 136 */ 0x00, 0x01, 0x04, 0x03, 0x06, 0x03, 0x03, 0x03,\
-/* 144 */ 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,\
-/* 152 */ 0x00, 0x00, 0x00, 0x01, 0x00, 0x10, 0x10, 0x01,\
-/* 160 */ 0x00, 0x00, 0x00,}
+/*  96 */ 0x12, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,\
+/* 104 */ 0x00, 0x01, 0x01, 0x01, 0x01, 0x04, 0x04, 0x00,\
+/* 112 */ 0x00, 0x10, 0x01, 0x01, 0x01, 0x01, 0x10, 0x00,\
+/* 120 */ 0x00, 0x10, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00,\
+/* 128 */ 0x00, 0x06, 0x23, 0x0b, 0x01, 0x10, 0x10, 0x00,\
+/* 136 */ 0x01, 0x04, 0x03, 0x1a, 0x03, 0x03, 0x03, 0x00,\
+/* 144 */ 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,\
+/* 152 */ 0x00, 0x00, 0x01, 0x00, 0x10, 0x10, 0x01, 0x00,\
+/* 160 */ 0x00, 0x00,}
 
 /************** End of opcodes.h *********************************************/
 /************** Continuing where we left off in vdbe.h ***********************/
@@ -10907,7 +10994,13 @@ SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe*,int,int,int,int);
 SQLITE_PRIVATE int sqlite3VdbeAddOp4(Vdbe*,int,int,int,int,const char *zP4,int);
 SQLITE_PRIVATE int sqlite3VdbeAddOp4Dup8(Vdbe*,int,int,int,int,const u8*,int);
 SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(Vdbe*,int,int,int,int,int);
-SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp, int iLineno);
+SQLITE_PRIVATE void sqlite3VdbeEndCoroutine(Vdbe*,int);
+#if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS)
+SQLITE_PRIVATE   void sqlite3VdbeVerifyNoMallocRequired(Vdbe *p, int N);
+#else
+# define sqlite3VdbeVerifyNoMallocRequired(A,B)
+#endif
+SQLITE_PRIVATE VdbeOp *sqlite3VdbeAddOpList(Vdbe*, int nOp, VdbeOpList const *aOp, int iLineno);
 SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe*,int,char*);
 SQLITE_PRIVATE void sqlite3VdbeChangeOpcode(Vdbe*, u32 addr, u8);
 SQLITE_PRIVATE void sqlite3VdbeChangeP1(Vdbe*, u32 addr, int P1);
@@ -10915,7 +11008,7 @@ SQLITE_PRIVATE void sqlite3VdbeChangeP2(Vdbe*, u32 addr, int P2);
 SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe*, u32 addr, int P3);
 SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe*, u8 P5);
 SQLITE_PRIVATE void sqlite3VdbeJumpHere(Vdbe*, int addr);
-SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe*, int addr);
+SQLITE_PRIVATE int sqlite3VdbeChangeToNoop(Vdbe*, int addr);
 SQLITE_PRIVATE int sqlite3VdbeDeletePriorOpcode(Vdbe*, u8 op);
 SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe*, int addr, const char *zP4, int N);
 SQLITE_PRIVATE void sqlite3VdbeSetP4KeyInfo(Parse*, Index*);
@@ -11125,11 +11218,12 @@ typedef struct PgHdr DbPage;
 #define PAGER_SYNCHRONOUS_OFF       0x01  /* PRAGMA synchronous=OFF */
 #define PAGER_SYNCHRONOUS_NORMAL    0x02  /* PRAGMA synchronous=NORMAL */
 #define PAGER_SYNCHRONOUS_FULL      0x03  /* PRAGMA synchronous=FULL */
-#define PAGER_SYNCHRONOUS_MASK      0x03  /* Mask for three values above */
-#define PAGER_FULLFSYNC             0x04  /* PRAGMA fullfsync=ON */
-#define PAGER_CKPT_FULLFSYNC        0x08  /* PRAGMA checkpoint_fullfsync=ON */
-#define PAGER_CACHESPILL            0x10  /* PRAGMA cache_spill=ON */
-#define PAGER_FLAGS_MASK            0x1c  /* All above except SYNCHRONOUS */
+#define PAGER_SYNCHRONOUS_EXTRA     0x04  /* PRAGMA synchronous=EXTRA */
+#define PAGER_SYNCHRONOUS_MASK      0x07  /* Mask for four values above */
+#define PAGER_FULLFSYNC             0x08  /* PRAGMA fullfsync=ON */
+#define PAGER_CKPT_FULLFSYNC        0x10  /* PRAGMA checkpoint_fullfsync=ON */
+#define PAGER_CACHESPILL            0x20  /* PRAGMA cache_spill=ON */
+#define PAGER_FLAGS_MASK            0x38  /* All above except SYNCHRONOUS */
 
 /*
 ** The remainder of this file contains the declarations of the functions
@@ -11319,6 +11413,8 @@ struct PgHdr {
 #define PGHDR_DONT_WRITE      0x020  /* Do not write content to disk */
 #define PGHDR_MMAP            0x040  /* This is an mmap page object */
 
+#define PGHDR_WAL_APPEND      0x080  /* Appended to wal file */
+
 /* Initialize and shutdown the page cache subsystem */
 SQLITE_PRIVATE int sqlite3PcacheInitialize(void);
 SQLITE_PRIVATE void sqlite3PcacheShutdown(void);
@@ -11887,8 +11983,8 @@ struct Schema {
 ** lookaside allocations are not used to construct the schema objects.
 */
 struct Lookaside {
+  u32 bDisable;           /* Only operate the lookaside when zero */
   u16 sz;                 /* Size of each buffer in bytes */
-  u8 bEnabled;            /* False to disable new lookaside allocations */
   u8 bMalloced;           /* True if pStart obtained from sqlite3_malloc() */
   int nOut;               /* Number of buffers currently checked out */
   int mxOut;              /* Highwater mark for nOut */
@@ -11971,6 +12067,7 @@ struct sqlite3 {
   u8 autoCommit;                /* The auto-commit flag. */
   u8 temp_store;                /* 1: file 2: memory 0: default */
   u8 mallocFailed;              /* True if we have seen a malloc failure */
+  u8 bBenignMalloc;             /* Do not require OOMs if true */
   u8 dfltLockMode;              /* Default locking-mode for attached dbs */
   signed char nextAutovac;      /* Autovac setting after VACUUM if >=0 */
   u8 suppressErr;               /* Do not issue error messages if true */
@@ -12079,10 +12176,10 @@ struct sqlite3 {
 */
 #define SQLITE_VdbeTrace      0x00000001  /* True to trace VDBE execution */
 #define SQLITE_InternChanges  0x00000002  /* Uncommitted Hash table changes */
-#define SQLITE_FullFSync      0x00000004  /* Use full fsync on the backend */
-#define SQLITE_CkptFullFSync  0x00000008  /* Use full fsync for checkpoint */
-#define SQLITE_CacheSpill     0x00000010  /* OK to spill pager cache */
-#define SQLITE_FullColNames   0x00000020  /* Show full column names on SELECT */
+#define SQLITE_FullColNames   0x00000004  /* Show full column names on SELECT */
+#define SQLITE_FullFSync      0x00000008  /* Use full fsync on the backend */
+#define SQLITE_CkptFullFSync  0x00000010  /* Use full fsync for checkpoint */
+#define SQLITE_CacheSpill     0x00000020  /* OK to spill pager cache */
 #define SQLITE_ShortColNames  0x00000040  /* Show short columns names */
 #define SQLITE_CountRows      0x00000080  /* Count rows changed by INSERT, */
                                           /*   DELETE, or UPDATE and return */
@@ -12171,9 +12268,8 @@ struct FuncDef {
   u16 funcFlags;       /* Some combination of SQLITE_FUNC_* */
   void *pUserData;     /* User data parameter */
   FuncDef *pNext;      /* Next function with same name */
-  void (*xFunc)(sqlite3_context*,int,sqlite3_value**); /* Regular function */
-  void (*xStep)(sqlite3_context*,int,sqlite3_value**); /* Aggregate step */
-  void (*xFinalize)(sqlite3_context*);                /* Aggregate finalizer */
+  void (*xSFunc)(sqlite3_context*,int,sqlite3_value**); /* func or agg-step */
+  void (*xFinalize)(sqlite3_context*);                  /* Agg finalizer */
   char *zName;         /* SQL name of the function. */
   FuncDef *pHash;      /* Next with a different name but the same hash */
   FuncDestructor *pDestructor;   /* Reference counted destructor function */
@@ -12256,28 +12352,28 @@ struct FuncDestructor {
 */
 #define FUNCTION(zName, nArg, iArg, bNC, xFunc) \
   {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
-   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
+   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, 0, 0}
 #define VFUNCTION(zName, nArg, iArg, bNC, xFunc) \
   {nArg, SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
-   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
+   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, 0, 0}
 #define DFUNCTION(zName, nArg, iArg, bNC, xFunc) \
   {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
-   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
+   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, 0, 0}
 #define FUNCTION2(zName, nArg, iArg, bNC, xFunc, extraFlags) \
   {nArg,SQLITE_FUNC_CONSTANT|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL)|extraFlags,\
-   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, 0, #zName, 0, 0}
+   SQLITE_INT_TO_PTR(iArg), 0, xFunc, 0, #zName, 0, 0}
 #define STR_FUNCTION(zName, nArg, pArg, bNC, xFunc) \
   {nArg, SQLITE_FUNC_SLOCHNG|SQLITE_UTF8|(bNC*SQLITE_FUNC_NEEDCOLL), \
-   pArg, 0, xFunc, 0, 0, #zName, 0, 0}
+   pArg, 0, xFunc, 0, #zName, 0, 0}
 #define LIKEFUNC(zName, nArg, arg, flags) \
   {nArg, SQLITE_FUNC_CONSTANT|SQLITE_UTF8|flags, \
-   (void *)arg, 0, likeFunc, 0, 0, #zName, 0, 0}
+   (void *)arg, 0, likeFunc, 0, #zName, 0, 0}
 #define AGGREGATE(zName, nArg, arg, nc, xStep, xFinal) \
   {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL), \
-   SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0}
+   SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,#zName,0,0}
 #define AGGREGATE2(zName, nArg, arg, nc, xStep, xFinal, extraFlags) \
   {nArg, SQLITE_UTF8|(nc*SQLITE_FUNC_NEEDCOLL)|extraFlags, \
-   SQLITE_INT_TO_PTR(arg), 0, 0, xStep,xFinal,#zName,0,0}
+   SQLITE_INT_TO_PTR(arg), 0, xStep,xFinal,#zName,0,0}
 
 /*
 ** All current savepoints are stored in a linked list starting at
@@ -13435,7 +13531,7 @@ struct SelectDest {
 ** tables, the following information is attached to the Table.u.autoInc.p
 ** pointer of each autoincrement table to record some side information that
 ** the code generator needs.  We have to keep per-table autoincrement
-** information in case inserts are down within triggers.  Triggers do not
+** information in case inserts are done within triggers.  Triggers do not
 ** normally coordinate their activities, but we do need to coordinate the
 ** loading and saving of autoincrement information.
 */
@@ -13527,6 +13623,7 @@ struct Parse {
   u8 mayAbort;         /* True if statement may throw an ABORT exception */
   u8 hasCompound;      /* Need to invoke convertCompoundSelectToSubquery() */
   u8 okConstFactor;    /* OK to factor out constants */
+  u8 disableLookaside; /* Number of times lookaside has been disabled */
   int aTempReg[8];     /* Holding area for temporary registers */
   int nRangeReg;       /* Size of the temporary register block */
   int iRangeReg;       /* First register in temporary register block */
@@ -13588,7 +13685,7 @@ struct Parse {
   ** in the recursive region.
   ************************************************************************/
 
-  int nVar;                 /* Number of '?' variables seen in the SQL so far */
+  ynVar nVar;               /* Number of '?' variables seen in the SQL so far */
   int nzVar;                /* Number of available slots in azVar[] */
   u8 iPkSortOrder;          /* ASC or DESC for INTEGER PRIMARY KEY */
   u8 explain;               /* True if the EXPLAIN flag is found on the query */
@@ -13641,7 +13738,8 @@ struct AuthContext {
 /*
 ** Bitfield flags for P5 value in various opcodes.
 */
-#define OPFLAG_NCHANGE       0x01    /* Set to update db->nChange */
+#define OPFLAG_NCHANGE       0x01    /* OP_Insert: Set to update db->nChange */
+                                     /* Also used in P2 (not P5) of OP_Delete */
 #define OPFLAG_EPHEM         0x01    /* OP_Column: Ephemeral output is ok */
 #define OPFLAG_LASTROWID     0x02    /* Set to update db->lastRowid */
 #define OPFLAG_ISUPDATE      0x04    /* This OP_Insert is an sql UPDATE */
@@ -13651,9 +13749,11 @@ struct AuthContext {
 #define OPFLAG_TYPEOFARG     0x80    /* OP_Column only used for typeof() */
 #define OPFLAG_BULKCSR       0x01    /* OP_Open** used to open bulk cursor */
 #define OPFLAG_SEEKEQ        0x02    /* OP_Open** cursor uses EQ seek only */
-#define OPFLAG_FORDELETE     0x08    /* OP_Open is opening for-delete csr */
+#define OPFLAG_FORDELETE     0x08    /* OP_Open should use BTREE_FORDELETE */
 #define OPFLAG_P2ISREG       0x10    /* P2 to OP_Open** is a register number */
 #define OPFLAG_PERMUTE       0x01    /* OP_Compare: use the permutation */
+#define OPFLAG_SAVEPOSITION  0x02    /* OP_Delete: keep cursor position */
+#define OPFLAG_AUXDELETE     0x04    /* OP_Delete: index in a DELETE op */
 
 /*
  * Each trigger present in the database schema is stored as an instance of
@@ -13772,10 +13872,16 @@ struct StrAccum {
   u32  nAlloc;         /* Amount of space allocated in zText */
   u32  mxAlloc;        /* Maximum allowed allocation.  0 for no malloc usage */
   u8   accError;       /* STRACCUM_NOMEM or STRACCUM_TOOBIG */
-  u8   bMalloced;      /* zText points to allocated space */
+  u8   printfFlags;    /* SQLITE_PRINTF flags below */
 };
 #define STRACCUM_NOMEM   1
 #define STRACCUM_TOOBIG  2
+#define SQLITE_PRINTF_INTERNAL 0x01  /* Internal-use-only converters allowed */
+#define SQLITE_PRINTF_SQLFUNC  0x02  /* SQL function arguments to VXPrintf */
+#define SQLITE_PRINTF_MALLOCED 0x04  /* True if xText is allocated space */
+
+#define isMalloced(X)  (((X)->printfFlags & SQLITE_PRINTF_MALLOCED)!=0)
+
 
 /*
 ** A pointer to this structure is used to communicate information
@@ -13870,10 +13976,10 @@ struct Sqlite3Config {
 ** Context pointer passed down through the tree-walk.
 */
 struct Walker {
+  Parse *pParse;                            /* Parser context.  */
   int (*xExprCallback)(Walker*, Expr*);     /* Callback for expressions */
   int (*xSelectCallback)(Walker*,Select*);  /* Callback for SELECTs */
   void (*xSelectCallback2)(Walker*,Select*);/* Second callback for SELECTs */
-  Parse *pParse;                            /* Parser context.  */
   int walkerDepth;                          /* Number of subqueries */
   u8 eCode;                                 /* A small processing code */
   union {                                   /* Extra data for callback */
@@ -13883,6 +13989,7 @@ struct Walker {
     SrcList *pSrcList;                         /* FROM clause */
     struct SrcCount *pSrcCount;                /* Counting column references */
     struct CCurHint *pCCurHint;                /* Used by codeCursorHint() */
+    int *aiCol;                                /* array of column indexes */
   } u;
 };
 
@@ -13952,6 +14059,13 @@ SQLITE_PRIVATE int sqlite3CantopenError(int);
 #define SQLITE_MISUSE_BKPT sqlite3MisuseError(__LINE__)
 #define SQLITE_CANTOPEN_BKPT sqlite3CantopenError(__LINE__)
 
+/*
+** FTS3 and FTS4 both require virtual table support
+*/
+#if defined(SQLITE_OMIT_VIRTUALTABLE)
+# undef SQLITE_ENABLE_FTS3
+# undef SQLITE_ENABLE_FTS4
+#endif
 
 /*
 ** FTS4 is really an extension for FTS3.  It is enabled using the
@@ -14010,6 +14124,7 @@ SQLITE_PRIVATE void *sqlite3Malloc(u64);
 SQLITE_PRIVATE void *sqlite3MallocZero(u64);
 SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3*, u64);
 SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3*, u64);
+SQLITE_PRIVATE void *sqlite3DbMallocRawNN(sqlite3*, u64);
 SQLITE_PRIVATE char *sqlite3DbStrDup(sqlite3*,const char*);
 SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3*,const char*, u64);
 SQLITE_PRIVATE void *sqlite3Realloc(void*, u64);
@@ -14092,10 +14207,8 @@ struct PrintfArguments {
   sqlite3_value **apArg;   /* The argument values */
 };
 
-#define SQLITE_PRINTF_INTERNAL 0x01
-#define SQLITE_PRINTF_SQLFUNC  0x02
-SQLITE_PRIVATE void sqlite3VXPrintf(StrAccum*, u32, const char*, va_list);
-SQLITE_PRIVATE void sqlite3XPrintf(StrAccum*, u32, const char*, ...);
+SQLITE_PRIVATE void sqlite3VXPrintf(StrAccum*, const char*, va_list);
+SQLITE_PRIVATE void sqlite3XPrintf(StrAccum*, const char*, ...);
 SQLITE_PRIVATE char *sqlite3MPrintf(sqlite3*,const char*, ...);
 SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3*,const char*, va_list);
 #if defined(SQLITE_DEBUG) || defined(SQLITE_HAVE_OS_TRACE)
@@ -14116,6 +14229,7 @@ SQLITE_PRIVATE   void sqlite3TreeViewWith(TreeView*, const With*, u8);
 SQLITE_PRIVATE void sqlite3SetString(char **, sqlite3*, const char*);
 SQLITE_PRIVATE void sqlite3ErrorMsg(Parse*, const char*, ...);
 SQLITE_PRIVATE int sqlite3Dequote(char*);
+SQLITE_PRIVATE void sqlite3TokenInit(Token*,char*);
 SQLITE_PRIVATE int sqlite3KeywordCode(const unsigned char*, int);
 SQLITE_PRIVATE int sqlite3RunParser(Parse*, const char*, char **);
 SQLITE_PRIVATE void sqlite3FinishCoding(Parse*);
@@ -14144,7 +14258,6 @@ SQLITE_PRIVATE void sqlite3Pragma(Parse*,Token*,Token*,Token*,int);
 SQLITE_PRIVATE void sqlite3ResetAllSchemasOfConnection(sqlite3*);
 SQLITE_PRIVATE void sqlite3ResetOneSchema(sqlite3*,int);
 SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3*);
-SQLITE_PRIVATE void sqlite3BeginParse(Parse*,int);
 SQLITE_PRIVATE void sqlite3CommitInternalChanges(sqlite3*);
 SQLITE_PRIVATE void sqlite3DeleteColumnNames(sqlite3*,Table*);
 SQLITE_PRIVATE int sqlite3ColumnsFromExprList(Parse*,ExprList*,i16*,Column**);
@@ -14329,7 +14442,7 @@ SQLITE_PRIVATE void sqlite3GenerateRowIndexDelete(Parse*, Table*, int, int, int*
 SQLITE_PRIVATE int sqlite3GenerateIndexKey(Parse*, Index*, int, int, int, int*,Index*,int);
 SQLITE_PRIVATE void sqlite3ResolvePartIdxLabel(Parse*,int);
 SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(Parse*,Table*,int*,int,int,int,int,
-                                     u8,u8,int,int*);
+                                     u8,u8,int,int*,int*);
 SQLITE_PRIVATE void sqlite3CompleteInsertion(Parse*,Table*,int,int,int,int*,int,int,int);
 SQLITE_PRIVATE int sqlite3OpenTableAndIndices(Parse*, Table*, int, u8, int, u8*, int*, int*);
 SQLITE_PRIVATE void sqlite3BeginWriteOperation(Parse*, int, int);
@@ -14548,7 +14661,6 @@ SQLITE_PRIVATE void sqlite3DeleteIndexSamples(sqlite3*,Index*);
 SQLITE_PRIVATE void sqlite3DefaultRowEst(Index*);
 SQLITE_PRIVATE void sqlite3RegisterLikeFunctions(sqlite3*, int);
 SQLITE_PRIVATE int sqlite3IsLikeFunction(sqlite3*,Expr*,int*,char*);
-SQLITE_PRIVATE void sqlite3MinimumFileFormat(Parse*, int, int);
 SQLITE_PRIVATE void sqlite3SchemaClear(void *);
 SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *, Btree *);
 SQLITE_PRIVATE int sqlite3SchemaToIndex(sqlite3 *db, Schema *);
@@ -14564,6 +14676,8 @@ SQLITE_PRIVATE int sqlite3CreateFunc(sqlite3 *, const char *, int, int, void *,
   void (*)(sqlite3_context*,int,sqlite3_value **), void (*)(sqlite3_context*),
   FuncDestructor *pDestructor
 );
+SQLITE_PRIVATE void sqlite3OomFault(sqlite3*);
+SQLITE_PRIVATE void sqlite3OomClear(sqlite3*);
 SQLITE_PRIVATE int sqlite3ApiExit(sqlite3 *db, int);
 SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *);
 
@@ -15660,6 +15774,7 @@ typedef struct AuxData AuxData;
 **      * A virtual table
 **      * A one-row "pseudotable" stored in a single register
 */
+typedef struct VdbeCursor VdbeCursor;
 struct VdbeCursor {
   u8 eCurType;          /* One of the CURTYPE_* values above */
   i8 iDb;               /* Index of cursor database in db->aDb[] (or -1) */
@@ -15668,6 +15783,7 @@ struct VdbeCursor {
   u8 isTable;           /* True for rowid tables.  False for indexes */
 #ifdef SQLITE_DEBUG
   u8 seekOp;            /* Most recent seek operation on this cursor */
+  u8 wrFlag;            /* The wrFlag argument to sqlite3BtreeCursor() */
 #endif
   Bool isEphemeral:1;   /* True for an ephemeral table */
   Bool useRandomRowid:1;/* Generate new record numbers semi-randomly */
@@ -15686,6 +15802,8 @@ struct VdbeCursor {
   int seekResult;       /* Result of previous sqlite3BtreeMoveto() */
   i64 seqCount;         /* Sequence counter */
   i64 movetoTarget;     /* Argument to the deferred sqlite3BtreeMoveto() */
+  VdbeCursor *pAltCursor; /* Associated index cursor from which to read */
+  int *aAltMap;           /* Mapping from table to index column numbers */
 #ifdef SQLITE_ENABLE_COLUMN_USED_MASK
   u64 maskUsed;         /* Mask of columns used by this cursor */
 #endif
@@ -15710,7 +15828,6 @@ struct VdbeCursor {
   ** static element declared in the structure.  nField total array slots for
   ** aType[] and nField+1 array slots for aOffset[] */
 };
-typedef struct VdbeCursor VdbeCursor;
 
 /*
 ** When a sub-program is executed (OP_Program), a structure of this type
@@ -15821,7 +15938,7 @@ struct Mem {
 #define MEM_Frame     0x0040   /* Value is a VdbeFrame object */
 #define MEM_Undefined 0x0080   /* Value is undefined */
 #define MEM_Cleared   0x0100   /* NULL set by OP_Null, not from data */
-#define MEM_TypeMask  0x01ff   /* Mask of type bits */
+#define MEM_TypeMask  0x81ff   /* Mask of type bits */
 
 
 /* Whenever Mem contains a valid string or blob representation, one of
@@ -15835,11 +15952,18 @@ struct Mem {
 #define MEM_Ephem     0x1000   /* Mem.z points to an ephemeral string */
 #define MEM_Agg       0x2000   /* Mem.z points to an agg function context */
 #define MEM_Zero      0x4000   /* Mem.i contains count of 0s appended to blob */
+#define MEM_Subtype   0x8000   /* Mem.eSubtype is valid */
 #ifdef SQLITE_OMIT_INCRBLOB
   #undef MEM_Zero
   #define MEM_Zero 0x0000
 #endif
 
+/* Return TRUE if Mem X contains dynamically allocated content - anything
+** that needs to be deallocated to avoid a leak.
+*/
+#define VdbeMemDynamic(X)  \
+  (((X)->flags&(MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame))!=0)
+
 /*
 ** Clear any existing type flags from a Mem and replace them with f
 */
@@ -16009,7 +16133,7 @@ struct Vdbe {
 SQLITE_PRIVATE void sqlite3VdbeError(Vdbe*, const char *, ...);
 SQLITE_PRIVATE void sqlite3VdbeFreeCursor(Vdbe *, VdbeCursor*);
 void sqliteVdbePopStack(Vdbe*,int);
-SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor*);
+SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor**, int*);
 SQLITE_PRIVATE int sqlite3VdbeCursorRestore(VdbeCursor*);
 #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
 SQLITE_PRIVATE void sqlite3VdbePrintOp(FILE*, int, Op*);
@@ -16055,8 +16179,6 @@ SQLITE_PRIVATE int sqlite3VdbeMemNumerify(Mem*);
 SQLITE_PRIVATE void sqlite3VdbeMemCast(Mem*,u8,u8);
 SQLITE_PRIVATE int sqlite3VdbeMemFromBtree(BtCursor*,u32,u32,int,Mem*);
 SQLITE_PRIVATE void sqlite3VdbeMemRelease(Mem *p);
-#define VdbeMemDynamic(X)  \
-  (((X)->flags&(MEM_Agg|MEM_Dyn|MEM_RowSet|MEM_Frame))!=0)
 SQLITE_PRIVATE int sqlite3VdbeMemFinalize(Mem*, FuncDef*);
 SQLITE_PRIVATE const char *sqlite3OpcodeName(int);
 SQLITE_PRIVATE int sqlite3VdbeMemGrow(Mem *pMem, int n, int preserve);
@@ -16075,11 +16197,15 @@ SQLITE_PRIVATE int sqlite3VdbeSorterRewind(const VdbeCursor *, int *);
 SQLITE_PRIVATE int sqlite3VdbeSorterWrite(const VdbeCursor *, Mem *);
 SQLITE_PRIVATE int sqlite3VdbeSorterCompare(const VdbeCursor *, Mem *, int, int *);
 
-#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
+#if !defined(SQLITE_OMIT_SHARED_CACHE) 
 SQLITE_PRIVATE   void sqlite3VdbeEnter(Vdbe*);
-SQLITE_PRIVATE   void sqlite3VdbeLeave(Vdbe*);
 #else
 # define sqlite3VdbeEnter(X)
+#endif
+
+#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
+SQLITE_PRIVATE   void sqlite3VdbeLeave(Vdbe*);
+#else
 # define sqlite3VdbeLeave(X)
 #endif
 
@@ -16517,34 +16643,49 @@ struct DateTime {
 
 
 /*
-** Convert zDate into one or more integers.  Additional arguments
-** come in groups of 5 as follows:
+** Convert zDate into one or more integers according to the conversion
+** specifier zFormat.
 **
-**       N       number of digits in the integer
-**       min     minimum allowed value of the integer
-**       max     maximum allowed value of the integer
-**       nextC   first character after the integer
-**       pVal    where to write the integers value.
+** zFormat[] contains 4 characters for each integer converted, except for
+** the last integer which is specified by three characters.  The meaning
+** of a four-character format specifiers ABCD is:
+**
+**    A:   number of digits to convert.  Always "2" or "4".
+**    B:   minimum value.  Always "0" or "1".
+**    C:   maximum value, decoded as:
+**           a:  12
+**           b:  14
+**           c:  24
+**           d:  31
+**           e:  59
+**           f:  9999
+**    D:   the separator character, or \000 to indicate this is the
+**         last number to convert.
+**
+** Example:  To translate an ISO-8601 date YYYY-MM-DD, the format would
+** be "40f-21a-20c".  The "40f-" indicates the 4-digit year followed by "-".
+** The "21a-" indicates the 2-digit month followed by "-".  The "20c" indicates
+** the 2-digit day which is the last integer in the set.
 **
-** Conversions continue until one with nextC==0 is encountered.
 ** The function returns the number of successful conversions.
 */
-static int getDigits(const char *zDate, ...){
+static int getDigits(const char *zDate, const char *zFormat, ...){
+  /* The aMx[] array translates the 3rd character of each format
+  ** spec into a max size:    a   b   c   d   e     f */
+  static const u16 aMx[] = { 12, 14, 24, 31, 59, 9999 };
   va_list ap;
-  int val;
-  int N;
-  int min;
-  int max;
-  int nextC;
-  int *pVal;
   int cnt = 0;
-  va_start(ap, zDate);
+  char nextC;
+  va_start(ap, zFormat);
   do{
-    N = va_arg(ap, int);
-    min = va_arg(ap, int);
-    max = va_arg(ap, int);
-    nextC = va_arg(ap, int);
-    pVal = va_arg(ap, int*);
+    char N = zFormat[0] - '0';
+    char min = zFormat[1] - '0';
+    int val = 0;
+    u16 max;
+
+    assert( zFormat[2]>='a' && zFormat[2]<='f' );
+    max = aMx[zFormat[2] - 'a'];
+    nextC = zFormat[3];
     val = 0;
     while( N-- ){
       if( !sqlite3Isdigit(*zDate) ){
@@ -16553,12 +16694,13 @@ static int getDigits(const char *zDate, ...){
       val = val*10 + *zDate - '0';
       zDate++;
     }
-    if( val<min || val>max || (nextC!=0 && nextC!=*zDate) ){
+    if( val<(int)min || val>(int)max || (nextC!=0 && nextC!=*zDate) ){
       goto end_getDigits;
     }
-    *pVal = val;
+    *va_arg(ap,int*) = val;
     zDate++;
     cnt++;
+    zFormat += 4;
   }while( nextC );
 end_getDigits:
   va_end(ap);
@@ -16599,7 +16741,7 @@ static int parseTimezone(const char *zDate, DateTime *p){
     return c!=0;
   }
   zDate++;
-  if( getDigits(zDate, 2, 0, 14, ':', &nHr, 2, 0, 59, 0, &nMn)!=2 ){
+  if( getDigits(zDate, "20b:20e", &nHr, &nMn)!=2 ){
     return 1;
   }
   zDate += 5;
@@ -16620,13 +16762,13 @@ zulu_time:
 static int parseHhMmSs(const char *zDate, DateTime *p){
   int h, m, s;
   double ms = 0.0;
-  if( getDigits(zDate, 2, 0, 24, ':', &h, 2, 0, 59, 0, &m)!=2 ){
+  if( getDigits(zDate, "20c:20e", &h, &m)!=2 ){
     return 1;
   }
   zDate += 5;
   if( *zDate==':' ){
     zDate++;
-    if( getDigits(zDate, 2, 0, 59, 0, &s)!=1 ){
+    if( getDigits(zDate, "20e", &s)!=1 ){
       return 1;
     }
     zDate += 2;
@@ -16714,7 +16856,7 @@ static int parseYyyyMmDd(const char *zDate, DateTime *p){
   }else{
     neg = 0;
   }
-  if( getDigits(zDate,4,0,9999,'-',&Y,2,1,12,'-',&M,2,1,31,0,&D)!=3 ){
+  if( getDigits(zDate, "40f-21a-21d", &Y, &M, &D)!=3 ){
     return 1;
   }
   zDate += 10;
@@ -16867,13 +17009,6 @@ static void clearYMD_HMS_TZ(DateTime *p){
 #define HAVE_LOCALTIME_S 1
 #endif
 
-#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
-#undef HAVE_LOCALTIME_S
-struct tm *__cdecl localtime(const time_t *t);
-#elif defined(_WIN32_WCE) && _WIN32_WCE >= 0x800
-#define SQLITE_MSVC_LOCALTIME_API 1
-#endif
-
 #ifndef SQLITE_OMIT_LOCALTIME
 /*
 ** The following routine implements the rough equivalent of localtime_r()
@@ -17405,7 +17540,7 @@ static void strftimeFunc(
     sqlite3_result_error_toobig(context);
     return;
   }else{
-    z = sqlite3DbMallocRaw(db, (int)n);
+    z = sqlite3DbMallocRawNN(db, (int)n);
     if( z==0 ){
       sqlite3_result_error_nomem(context);
       return;
@@ -17620,6 +17755,28 @@ SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void){
 /* #include "sqliteInt.h" */
 #undef _SQLITE_OS_C_
 
+/*
+** If we compile with the SQLITE_TEST macro set, then the following block
+** of code will give us the ability to simulate a disk I/O error.  This
+** is used for testing the I/O recovery logic.
+*/
+#if defined(SQLITE_TEST)
+SQLITE_API int sqlite3_io_error_hit = 0;            /* Total number of I/O Errors */
+SQLITE_API int sqlite3_io_error_hardhit = 0;        /* Number of non-benign errors */
+SQLITE_API int sqlite3_io_error_pending = 0;        /* Count down to first I/O error */
+SQLITE_API int sqlite3_io_error_persist = 0;        /* True if I/O errors persist */
+SQLITE_API int sqlite3_io_error_benign = 0;         /* True if errors are benign */
+SQLITE_API int sqlite3_diskfull_pending = 0;
+SQLITE_API int sqlite3_diskfull = 0;
+#endif /* defined(SQLITE_TEST) */
+
+/*
+** When testing, also keep a count of the number of open files.
+*/
+#if defined(SQLITE_TEST)
+SQLITE_API int sqlite3_open_file_count = 0;
+#endif /* defined(SQLITE_TEST) */
+
 /*
 ** The default SQLite sqlite3_vfs implementations do not allocate
 ** memory (actually, os_unix.c allocates a small amount of memory
@@ -17627,7 +17784,7 @@ SQLITE_PRIVATE void sqlite3RegisterDateTimeFunctions(void){
 ** So we test the effects of a malloc() failing and the sqlite3OsXXX()
 ** function returning SQLITE_IOERR_NOMEM using the DO_OS_MALLOC_TEST macro.
 **
-** The following functions are instrumented for malloc() failure 
+** The following functions are instrumented for malloc() failure
 ** testing:
 **
 **     sqlite3OsRead()
@@ -17713,8 +17870,8 @@ SQLITE_PRIVATE int sqlite3OsFileControl(sqlite3_file *id, int op, void *pArg){
 #ifdef SQLITE_TEST
   if( op!=SQLITE_FCNTL_COMMIT_PHASETWO ){
     /* Faults are not injected into COMMIT_PHASETWO because, assuming SQLite
-    ** is using a regular VFS, it is called after the corresponding 
-    ** transaction has been committed. Injecting a fault at this point 
+    ** is using a regular VFS, it is called after the corresponding
+    ** transaction has been committed. Injecting a fault at this point
     ** confuses the test scripts - the COMMIT comand returns SQLITE_NOMEM
     ** but the transaction is committed anyway.
     **
@@ -17783,10 +17940,10 @@ SQLITE_PRIVATE int sqlite3OsUnfetch(sqlite3_file *id, i64 iOff, void *p){
 ** VFS methods.
 */
 SQLITE_PRIVATE int sqlite3OsOpen(
-  sqlite3_vfs *pVfs, 
-  const char *zPath, 
-  sqlite3_file *pFile, 
-  int flags, 
+  sqlite3_vfs *pVfs,
+  const char *zPath,
+  sqlite3_file *pFile,
+  int flags,
   int *pFlagsOut
 ){
   int rc;
@@ -17805,18 +17962,18 @@ SQLITE_PRIVATE int sqlite3OsDelete(sqlite3_vfs *pVfs, const char *zPath, int dir
   return pVfs->xDelete(pVfs, zPath, dirSync);
 }
 SQLITE_PRIVATE int sqlite3OsAccess(
-  sqlite3_vfs *pVfs, 
-  const char *zPath, 
-  int flags, 
+  sqlite3_vfs *pVfs,
+  const char *zPath,
+  int flags,
   int *pResOut
 ){
   DO_OS_MALLOC_TEST(0);
   return pVfs->xAccess(pVfs, zPath, flags, pResOut);
 }
 SQLITE_PRIVATE int sqlite3OsFullPathname(
-  sqlite3_vfs *pVfs, 
-  const char *zPath, 
-  int nPathOut, 
+  sqlite3_vfs *pVfs,
+  const char *zPath,
+  int nPathOut,
   char *zPathOut
 ){
   DO_OS_MALLOC_TEST(0);
@@ -17862,9 +18019,9 @@ SQLITE_PRIVATE int sqlite3OsCurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p
 }
 
 SQLITE_PRIVATE int sqlite3OsOpenMalloc(
-  sqlite3_vfs *pVfs, 
-  const char *zFile, 
-  sqlite3_file **ppFile, 
+  sqlite3_vfs *pVfs,
+  const char *zFile,
+  sqlite3_file **ppFile,
   int flags,
   int *pOutFlags
 ){
@@ -19774,6 +19931,7 @@ static SQLITE_WSD struct Mem5Global {
   */
   sqlite3_mutex *mutex;
 
+#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
   /*
   ** Performance statistics
   */
@@ -19785,6 +19943,7 @@ static SQLITE_WSD struct Mem5Global {
   u32 maxOut;         /* Maximum instantaneous currentOut */
   u32 maxCount;       /* Maximum instantaneous currentCount */
   u32 maxRequest;     /* Largest allocation (exclusive of internal frag) */
+#endif
   
   /*
   ** Lists of free blocks.  aiFreelist[0] is a list of free blocks of
@@ -19896,14 +20055,17 @@ static void *memsys5MallocUnsafe(int nByte){
   /* nByte must be a positive */
   assert( nByte>0 );
 
+  /* No more than 1GiB per allocation */
+  if( nByte > 0x40000000 ) return 0;
+
+#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
   /* Keep track of the maximum allocation request.  Even unfulfilled
   ** requests are counted */
   if( (u32)nByte>mem5.maxRequest ){
-    /* Abort if the requested allocation size is larger than the largest
-    ** power of two that we can represent using 32-bit signed integers. */
-    if( nByte > 0x40000000 ) return 0;
     mem5.maxRequest = nByte;
   }
+#endif
+
 
   /* Round nByte up to the next valid power of two */
   for(iFullSz=mem5.szAtom,iLogsize=0; iFullSz<nByte; iFullSz*=2,iLogsize++){}
@@ -19930,6 +20092,7 @@ static void *memsys5MallocUnsafe(int nByte){
   }
   mem5.aCtrl[i] = iLogsize;
 
+#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
   /* Update allocator performance statistics. */
   mem5.nAlloc++;
   mem5.totalAlloc += iFullSz;
@@ -19938,6 +20101,7 @@ static void *memsys5MallocUnsafe(int nByte){
   mem5.currentOut += iFullSz;
   if( mem5.maxCount<mem5.currentCount ) mem5.maxCount = mem5.currentCount;
   if( mem5.maxOut<mem5.currentOut ) mem5.maxOut = mem5.currentOut;
+#endif
 
 #ifdef SQLITE_DEBUG
   /* Make sure the allocated memory does not assume that it is set to zero
@@ -19972,23 +20136,26 @@ static void memsys5FreeUnsafe(void *pOld){
 
   mem5.aCtrl[iBlock] |= CTRL_FREE;
   mem5.aCtrl[iBlock+size-1] |= CTRL_FREE;
+
+#if defined(SQLITE_DEBUG) || defined(SQLITE_TEST)
   assert( mem5.currentCount>0 );
   assert( mem5.currentOut>=(size*mem5.szAtom) );
   mem5.currentCount--;
   mem5.currentOut -= size*mem5.szAtom;
   assert( mem5.currentOut>0 || mem5.currentCount==0 );
   assert( mem5.currentCount>0 || mem5.currentOut==0 );
+#endif
 
   mem5.aCtrl[iBlock] = CTRL_FREE | iLogsize;
   while( ALWAYS(iLogsize<LOGMAX) ){
     int iBuddy;
     if( (iBlock>>iLogsize) & 1 ){
       iBuddy = iBlock - size;
+      assert( iBuddy>=0 );
     }else{
       iBuddy = iBlock + size;
+      if( iBuddy>=mem5.nBlock ) break;
     }
-    assert( iBuddy>=0 );
-    if( (iBuddy+(1<<iLogsize))>mem5.nBlock ) break;
     if( mem5.aCtrl[iBuddy]!=(CTRL_FREE | iLogsize) ) break;
     memsys5Unlink(iBuddy, iLogsize);
     iLogsize++;
@@ -21077,8 +21244,8 @@ SQLITE_PRIVATE sqlite3_mutex_methods const *sqlite3DefaultMutex(void){
 */
 #ifdef SQLITE_PERFORMANCE_TRACE
 
-/* 
-** hwtime.h contains inline assembler code for implementing 
+/*
+** hwtime.h contains inline assembler code for implementing
 ** high-performance timing routines.
 */
 /************** Include hwtime.h in the middle of os_common.h ****************/
@@ -21188,14 +21355,14 @@ static sqlite_uint64 g_elapsed;
 ** of code will give us the ability to simulate a disk I/O error.  This
 ** is used for testing the I/O recovery logic.
 */
-#ifdef SQLITE_TEST
-SQLITE_API int sqlite3_io_error_hit = 0;            /* Total number of I/O Errors */
-SQLITE_API int sqlite3_io_error_hardhit = 0;        /* Number of non-benign errors */
-SQLITE_API int sqlite3_io_error_pending = 0;        /* Count down to first I/O error */
-SQLITE_API int sqlite3_io_error_persist = 0;        /* True if I/O errors persist */
-SQLITE_API int sqlite3_io_error_benign = 0;         /* True if errors are benign */
-SQLITE_API int sqlite3_diskfull_pending = 0;
-SQLITE_API int sqlite3_diskfull = 0;
+#if defined(SQLITE_TEST)
+SQLITE_API extern int sqlite3_io_error_hit;
+SQLITE_API extern int sqlite3_io_error_hardhit;
+SQLITE_API extern int sqlite3_io_error_pending;
+SQLITE_API extern int sqlite3_io_error_persist;
+SQLITE_API extern int sqlite3_io_error_benign;
+SQLITE_API extern int sqlite3_diskfull_pending;
+SQLITE_API extern int sqlite3_diskfull;
 #define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X)
 #define SimulateIOError(CODE)  \
   if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \
@@ -21221,17 +21388,17 @@ static void local_ioerr(){
 #define SimulateIOErrorBenign(X)
 #define SimulateIOError(A)
 #define SimulateDiskfullError(A)
-#endif
+#endif /* defined(SQLITE_TEST) */
 
 /*
 ** When testing, keep a count of the number of open files.
 */
-#ifdef SQLITE_TEST
-SQLITE_API int sqlite3_open_file_count = 0;
+#if defined(SQLITE_TEST)
+SQLITE_API extern int sqlite3_open_file_count;
 #define OpenCounter(X)  sqlite3_open_file_count+=(X)
 #else
 #define OpenCounter(X)
-#endif
+#endif /* defined(SQLITE_TEST) */
 
 #endif /* !defined(_OS_COMMON_H_) */
 
@@ -22289,16 +22456,31 @@ SQLITE_PRIVATE void *sqlite3MallocZero(u64 n){
 ** the mallocFailed flag in the connection pointer.
 */
 SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3 *db, u64 n){
-  void *p = sqlite3DbMallocRaw(db, n);
-  if( p ){
-    memset(p, 0, (size_t)n);
-  }
+  void *p;
+  testcase( db==0 );
+  p = sqlite3DbMallocRaw(db, n);
+  if( p ) memset(p, 0, (size_t)n);
+  return p;
+}
+
+
+/* Finish the work of sqlite3DbMallocRawNN for the unusual and
+** slower case when the allocation cannot be fulfilled using lookaside.
+*/
+static SQLITE_NOINLINE void *dbMallocRawFinish(sqlite3 *db, u64 n){
+  void *p;
+  assert( db!=0 );
+  p = sqlite3Malloc(n);
+  if( !p ) sqlite3OomFault(db);
+  sqlite3MemdebugSetType(p, 
+         (db->lookaside.bDisable==0) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP);
   return p;
 }
 
 /*
-** Allocate and zero memory.  If the allocation fails, make
-** the mallocFailed flag in the connection pointer.
+** Allocate memory, either lookaside (if possible) or heap.  
+** If the allocation fails, set the mallocFailed flag in
+** the connection pointer.
 **
 ** If db!=0 and db->mallocFailed is true (indicating a prior malloc
 ** failure on the same database connection) then always return 0.
@@ -22313,64 +22495,73 @@ SQLITE_PRIVATE void *sqlite3DbMallocZero(sqlite3 *db, u64 n){
 **
 ** In other words, if a subsequent malloc (ex: "b") worked, it is assumed
 ** that all prior mallocs (ex: "a") worked too.
+**
+** The sqlite3MallocRawNN() variant guarantees that the "db" parameter is
+** not a NULL pointer.
 */
 SQLITE_PRIVATE void *sqlite3DbMallocRaw(sqlite3 *db, u64 n){
   void *p;
-  assert( db==0 || sqlite3_mutex_held(db->mutex) );
-  assert( db==0 || db->pnBytesFreed==0 );
+  if( db ) return sqlite3DbMallocRawNN(db, n);
+  p = sqlite3Malloc(n);
+  sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
+  return p;
+}
+SQLITE_PRIVATE void *sqlite3DbMallocRawNN(sqlite3 *db, u64 n){
 #ifndef SQLITE_OMIT_LOOKASIDE
-  if( db ){
-    LookasideSlot *pBuf;
-    if( db->mallocFailed ){
-      return 0;
-    }
-    if( db->lookaside.bEnabled ){
-      if( n>db->lookaside.sz ){
-        db->lookaside.anStat[1]++;
-      }else if( (pBuf = db->lookaside.pFree)==0 ){
-        db->lookaside.anStat[2]++;
-      }else{
-        db->lookaside.pFree = pBuf->pNext;
-        db->lookaside.nOut++;
-        db->lookaside.anStat[0]++;
-        if( db->lookaside.nOut>db->lookaside.mxOut ){
-          db->lookaside.mxOut = db->lookaside.nOut;
-        }
-        return (void*)pBuf;
+  LookasideSlot *pBuf;
+  assert( db!=0 );
+  assert( sqlite3_mutex_held(db->mutex) );
+  assert( db->pnBytesFreed==0 );
+  if( db->lookaside.bDisable==0 ){
+    assert( db->mallocFailed==0 );
+    if( n>db->lookaside.sz ){
+      db->lookaside.anStat[1]++;
+    }else if( (pBuf = db->lookaside.pFree)==0 ){
+      db->lookaside.anStat[2]++;
+    }else{
+      db->lookaside.pFree = pBuf->pNext;
+      db->lookaside.nOut++;
+      db->lookaside.anStat[0]++;
+      if( db->lookaside.nOut>db->lookaside.mxOut ){
+        db->lookaside.mxOut = db->lookaside.nOut;
       }
+      return (void*)pBuf;
     }
+  }else if( db->mallocFailed ){
+    return 0;
   }
 #else
-  if( db && db->mallocFailed ){
+  assert( db!=0 );
+  assert( sqlite3_mutex_held(db->mutex) );
+  assert( db->pnBytesFreed==0 );
+  if( db->mallocFailed ){
     return 0;
   }
 #endif
-  p = sqlite3Malloc(n);
-  if( !p && db ){
-    db->mallocFailed = 1;
-  }
-  sqlite3MemdebugSetType(p, 
-         (db && db->lookaside.bEnabled) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP);
-  return p;
+  return dbMallocRawFinish(db, n);
 }
 
+/* Forward declaration */
+static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n);
+
 /*
 ** Resize the block of memory pointed to by p to n bytes. If the
 ** resize fails, set the mallocFailed flag in the connection object.
 */
 SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){
+  assert( db!=0 );
+  if( p==0 ) return sqlite3DbMallocRawNN(db, n);
+  assert( sqlite3_mutex_held(db->mutex) );
+  if( isLookaside(db,p) && n<=db->lookaside.sz ) return p;
+  return dbReallocFinish(db, p, n);
+}
+static SQLITE_NOINLINE void *dbReallocFinish(sqlite3 *db, void *p, u64 n){
   void *pNew = 0;
   assert( db!=0 );
-  assert( sqlite3_mutex_held(db->mutex) );
+  assert( p!=0 );
   if( db->mallocFailed==0 ){
-    if( p==0 ){
-      return sqlite3DbMallocRaw(db, n);
-    }
     if( isLookaside(db, p) ){
-      if( n<=db->lookaside.sz ){
-        return p;
-      }
-      pNew = sqlite3DbMallocRaw(db, n);
+      pNew = sqlite3DbMallocRawNN(db, n);
       if( pNew ){
         memcpy(pNew, p, db->lookaside.sz);
         sqlite3DbFree(db, p);
@@ -22381,10 +22572,10 @@ SQLITE_PRIVATE void *sqlite3DbRealloc(sqlite3 *db, void *p, u64 n){
       sqlite3MemdebugSetType(p, MEMTYPE_HEAP);
       pNew = sqlite3_realloc64(p, n);
       if( !pNew ){
-        db->mallocFailed = 1;
+        sqlite3OomFault(db);
       }
       sqlite3MemdebugSetType(pNew,
-            (db->lookaside.bEnabled ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
+            (db->lookaside.bDisable==0 ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP));
     }
   }
   return pNew;
@@ -22426,11 +22617,12 @@ SQLITE_PRIVATE char *sqlite3DbStrDup(sqlite3 *db, const char *z){
 }
 SQLITE_PRIVATE char *sqlite3DbStrNDup(sqlite3 *db, const char *z, u64 n){
   char *zNew;
+  assert( db!=0 );
   if( z==0 ){
     return 0;
   }
   assert( (n&0x7fffffff)==n );
-  zNew = sqlite3DbMallocRaw(db, n+1);
+  zNew = sqlite3DbMallocRawNN(db, n+1);
   if( zNew ){
     memcpy(zNew, z, (size_t)n);
     zNew[n] = 0;
@@ -22446,11 +22638,43 @@ SQLITE_PRIVATE void sqlite3SetString(char **pz, sqlite3 *db, const char *zNew){
   *pz = sqlite3DbStrDup(db, zNew);
 }
 
+/*
+** Call this routine to record the fact that an OOM (out-of-memory) error
+** has happened.  This routine will set db->mallocFailed, and also
+** temporarily disable the lookaside memory allocator and interrupt
+** any running VDBEs.
+*/
+SQLITE_PRIVATE void sqlite3OomFault(sqlite3 *db){
+  if( db->mallocFailed==0 && db->bBenignMalloc==0 ){
+    db->mallocFailed = 1;
+    if( db->nVdbeExec>0 ){
+      db->u1.isInterrupted = 1;
+    }
+    db->lookaside.bDisable++;
+  }
+}
+
+/*
+** This routine reactivates the memory allocator and clears the
+** db->mallocFailed flag as necessary.
+**
+** The memory allocator is not restarted if there are running
+** VDBEs.
+*/
+SQLITE_PRIVATE void sqlite3OomClear(sqlite3 *db){
+  if( db->mallocFailed && db->nVdbeExec==0 ){
+    db->mallocFailed = 0;
+    db->u1.isInterrupted = 0;
+    assert( db->lookaside.bDisable>0 );
+    db->lookaside.bDisable--;
+  }
+}
+
 /*
 ** Take actions at the end of an API call to indicate an OOM error
 */
 static SQLITE_NOINLINE int apiOomError(sqlite3 *db){
-  db->mallocFailed = 0;
+  sqlite3OomClear(db);
   sqlite3Error(db, SQLITE_NOMEM);
   return SQLITE_NOMEM;
 }
@@ -22655,7 +22879,6 @@ static char *getTextArg(PrintfArguments *p){
 */
 SQLITE_PRIVATE void sqlite3VXPrintf(
   StrAccum *pAccum,          /* Accumulate results here */
-  u32 bFlags,                /* SQLITE_PRINTF_* flags */
   const char *fmt,           /* Format string */
   va_list ap                 /* arguments */
 ){
@@ -22695,11 +22918,11 @@ SQLITE_PRIVATE void sqlite3VXPrintf(
   char buf[etBUFSIZE];       /* Conversion buffer */
 
   bufpt = 0;
-  if( bFlags ){
-    if( (bArgList = (bFlags & SQLITE_PRINTF_SQLFUNC))!=0 ){
+  if( pAccum->printfFlags ){
+    if( (bArgList = (pAccum->printfFlags & SQLITE_PRINTF_SQLFUNC))!=0 ){
       pArgList = va_arg(ap, PrintfArguments*);
     }
-    useIntern = bFlags & SQLITE_PRINTF_INTERNAL;
+    useIntern = pAccum->printfFlags & SQLITE_PRINTF_INTERNAL;
   }else{
     bArgList = useIntern = 0;
   }
@@ -23250,9 +23473,9 @@ static int sqlite3StrAccumEnlarge(StrAccum *p, int N){
     setStrAccumError(p, STRACCUM_TOOBIG);
     return N;
   }else{
-    char *zOld = p->bMalloced ? p->zText : 0;
+    char *zOld = isMalloced(p) ? p->zText : 0;
     i64 szNew = p->nChar;
-    assert( (p->zText==0 || p->zText==p->zBase)==(p->bMalloced==0) );
+    assert( (p->zText==0 || p->zText==p->zBase)==!isMalloced(p) );
     szNew += N + 1;
     if( szNew+p->nChar<=p->mxAlloc ){
       /* Force exponential buffer size growth as long as it does not overflow,
@@ -23273,10 +23496,10 @@ static int sqlite3StrAccumEnlarge(StrAccum *p, int N){
     }
     if( zNew ){
       assert( p->zText!=0 || p->nChar==0 );
-      if( !p->bMalloced && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar);
+      if( !isMalloced(p) && p->nChar>0 ) memcpy(zNew, p->zText, p->nChar);
       p->zText = zNew;
       p->nAlloc = sqlite3DbMallocSize(p->db, zNew);
-      p->bMalloced = 1;
+      p->printfFlags |= SQLITE_PRINTF_MALLOCED;
     }else{
       sqlite3StrAccumReset(p);
       setStrAccumError(p, STRACCUM_NOMEM);
@@ -23294,7 +23517,7 @@ SQLITE_PRIVATE void sqlite3AppendChar(StrAccum *p, int N, char c){
   if( p->nChar+(i64)N >= p->nAlloc && (N = sqlite3StrAccumEnlarge(p, N))<=0 ){
     return;
   }
-  assert( (p->zText==p->zBase)==(p->bMalloced==0) );
+  assert( (p->zText==p->zBase)==!isMalloced(p) );
   while( (N--)>0 ) p->zText[p->nChar++] = c;
 }
 
@@ -23312,7 +23535,7 @@ static void SQLITE_NOINLINE enlargeAndAppend(StrAccum *p, const char *z, int N){
     memcpy(&p->zText[p->nChar], z, N);
     p->nChar += N;
   }
-  assert( (p->zText==0 || p->zText==p->zBase)==(p->bMalloced==0) );
+  assert( (p->zText==0 || p->zText==p->zBase)==!isMalloced(p) );
 }
 
 /*
@@ -23348,13 +23571,13 @@ SQLITE_PRIVATE void sqlite3StrAccumAppendAll(StrAccum *p, const char *z){
 */
 SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){
   if( p->zText ){
-    assert( (p->zText==p->zBase)==(p->bMalloced==0) );
+    assert( (p->zText==p->zBase)==!isMalloced(p) );
     p->zText[p->nChar] = 0;
-    if( p->mxAlloc>0 && p->bMalloced==0 ){
+    if( p->mxAlloc>0 && !isMalloced(p) ){
       p->zText = sqlite3DbMallocRaw(p->db, p->nChar+1 );
       if( p->zText ){
         memcpy(p->zText, p->zBase, p->nChar+1);
-        p->bMalloced = 1;
+        p->printfFlags |= SQLITE_PRINTF_MALLOCED;
       }else{
         setStrAccumError(p, STRACCUM_NOMEM);
       }
@@ -23367,10 +23590,10 @@ SQLITE_PRIVATE char *sqlite3StrAccumFinish(StrAccum *p){
 ** Reset an StrAccum string.  Reclaim all malloced memory.
 */
 SQLITE_PRIVATE void sqlite3StrAccumReset(StrAccum *p){
-  assert( (p->zText==0 || p->zText==p->zBase)==(p->bMalloced==0) );
-  if( p->bMalloced ){
+  assert( (p->zText==0 || p->zText==p->zBase)==!isMalloced(p) );
+  if( isMalloced(p) ){
     sqlite3DbFree(p->db, p->zText);
-    p->bMalloced = 0;
+    p->printfFlags &= ~SQLITE_PRINTF_MALLOCED;
   }
   p->zText = 0;
 }
@@ -23396,7 +23619,7 @@ SQLITE_PRIVATE void sqlite3StrAccumInit(StrAccum *p, sqlite3 *db, char *zBase, i
   p->nAlloc = n;
   p->mxAlloc = mx;
   p->accError = 0;
-  p->bMalloced = 0;
+  p->printfFlags = 0;
 }
 
 /*
@@ -23410,10 +23633,11 @@ SQLITE_PRIVATE char *sqlite3VMPrintf(sqlite3 *db, const char *zFormat, va_list a
   assert( db!=0 );
   sqlite3StrAccumInit(&acc, db, zBase, sizeof(zBase),
                       db->aLimit[SQLITE_LIMIT_LENGTH]);
-  sqlite3VXPrintf(&acc, SQLITE_PRINTF_INTERNAL, zFormat, ap);
+  acc.printfFlags = SQLITE_PRINTF_INTERNAL;
+  sqlite3VXPrintf(&acc, zFormat, ap);
   z = sqlite3StrAccumFinish(&acc);
   if( acc.accError==STRACCUM_NOMEM ){
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
   }
   return z;
 }
@@ -23450,7 +23674,7 @@ SQLITE_API char *SQLITE_STDCALL sqlite3_vmprintf(const char *zFormat, va_list ap
   if( sqlite3_initialize() ) return 0;
 #endif
   sqlite3StrAccumInit(&acc, 0, zBase, sizeof(zBase), SQLITE_MAX_LENGTH);
-  sqlite3VXPrintf(&acc, 0, zFormat, ap);
+  sqlite3VXPrintf(&acc, zFormat, ap);
   z = sqlite3StrAccumFinish(&acc);
   return z;
 }
@@ -23495,7 +23719,7 @@ SQLITE_API char *SQLITE_STDCALL sqlite3_vsnprintf(int n, char *zBuf, const char
   }
 #endif
   sqlite3StrAccumInit(&acc, 0, zBuf, n, 0);
-  sqlite3VXPrintf(&acc, 0, zFormat, ap);
+  sqlite3VXPrintf(&acc, zFormat, ap);
   return sqlite3StrAccumFinish(&acc);
 }
 SQLITE_API char *SQLITE_CDECL sqlite3_snprintf(int n, char *zBuf, const char *zFormat, ...){
@@ -23526,7 +23750,7 @@ static void renderLogMsg(int iErrCode, const char *zFormat, va_list ap){
   char zMsg[SQLITE_PRINT_BUF_SIZE*3];    /* Complete log message */
 
   sqlite3StrAccumInit(&acc, 0, zMsg, sizeof(zMsg), 0);
-  sqlite3VXPrintf(&acc, 0, zFormat, ap);
+  sqlite3VXPrintf(&acc, zFormat, ap);
   sqlite3GlobalConfig.xLog(sqlite3GlobalConfig.pLogArg, iErrCode,
                            sqlite3StrAccumFinish(&acc));
 }
@@ -23555,7 +23779,7 @@ SQLITE_PRIVATE void sqlite3DebugPrintf(const char *zFormat, ...){
   char zBuf[500];
   sqlite3StrAccumInit(&acc, 0, zBuf, sizeof(zBuf), 0);
   va_start(ap,zFormat);
-  sqlite3VXPrintf(&acc, 0, zFormat, ap);
+  sqlite3VXPrintf(&acc, zFormat, ap);
   va_end(ap);
   sqlite3StrAccumFinish(&acc);
   fprintf(stdout,"%s", zBuf);
@@ -23568,10 +23792,10 @@ SQLITE_PRIVATE void sqlite3DebugPrintf(const char *zFormat, ...){
 ** variable-argument wrapper around sqlite3VXPrintf().  The bFlags argument
 ** can contain the bit SQLITE_PRINTF_INTERNAL enable internal formats.
 */
-SQLITE_PRIVATE void sqlite3XPrintf(StrAccum *p, u32 bFlags, const char *zFormat, ...){
+SQLITE_PRIVATE void sqlite3XPrintf(StrAccum *p, const char *zFormat, ...){
   va_list ap;
   va_start(ap,zFormat);
-  sqlite3VXPrintf(p, bFlags, zFormat, ap);
+  sqlite3VXPrintf(p, zFormat, ap);
   va_end(ap);
 }
 
@@ -23642,7 +23866,7 @@ static void sqlite3TreeViewLine(TreeView *p, const char *zFormat, ...){
     sqlite3StrAccumAppend(&acc, p->bLine[i] ? "|-- " : "'-- ", 4);
   }
   va_start(ap, zFormat);
-  sqlite3VXPrintf(&acc, 0, zFormat, ap);
+  sqlite3VXPrintf(&acc, zFormat, ap);
   va_end(ap);
   if( zBuf[acc.nChar-1]!='\n' ) sqlite3StrAccumAppend(&acc, "\n", 1);
   sqlite3StrAccumFinish(&acc);
@@ -23677,17 +23901,17 @@ SQLITE_PRIVATE void sqlite3TreeViewWith(TreeView *pView, const With *pWith, u8 m
       char zLine[1000];
       const struct Cte *pCte = &pWith->a[i];
       sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0);
-      sqlite3XPrintf(&x, 0, "%s", pCte->zName);
+      sqlite3XPrintf(&x, "%s", pCte->zName);
       if( pCte->pCols && pCte->pCols->nExpr>0 ){
         char cSep = '(';
         int j;
         for(j=0; j<pCte->pCols->nExpr; j++){
-          sqlite3XPrintf(&x, 0, "%c%s", cSep, pCte->pCols->a[j].zName);
+          sqlite3XPrintf(&x, "%c%s", cSep, pCte->pCols->a[j].zName);
           cSep = ',';
         }
-        sqlite3XPrintf(&x, 0, ")");
+        sqlite3XPrintf(&x, ")");
       }
-      sqlite3XPrintf(&x, 0, " AS");
+      sqlite3XPrintf(&x, " AS");
       sqlite3StrAccumFinish(&x);
       sqlite3TreeViewItem(pView, zLine, i<pWith->nCte-1);
       sqlite3TreeViewSelect(pView, pCte->pSelect, 0);
@@ -23738,20 +23962,20 @@ SQLITE_PRIVATE void sqlite3TreeViewSelect(TreeView *pView, const Select *p, u8 m
         StrAccum x;
         char zLine[100];
         sqlite3StrAccumInit(&x, 0, zLine, sizeof(zLine), 0);
-        sqlite3XPrintf(&x, 0, "{%d,*}", pItem->iCursor);
+        sqlite3XPrintf(&x, "{%d,*}", pItem->iCursor);
         if( pItem->zDatabase ){
-          sqlite3XPrintf(&x, 0, " %s.%s", pItem->zDatabase, pItem->zName);
+          sqlite3XPrintf(&x, " %s.%s", pItem->zDatabase, pItem->zName);
         }else if( pItem->zName ){
-          sqlite3XPrintf(&x, 0, " %s", pItem->zName);
+          sqlite3XPrintf(&x, " %s", pItem->zName);
         }
         if( pItem->pTab ){
-          sqlite3XPrintf(&x, 0, " tabname=%Q", pItem->pTab->zName);
+          sqlite3XPrintf(&x, " tabname=%Q", pItem->pTab->zName);
         }
         if( pItem->zAlias ){
-          sqlite3XPrintf(&x, 0, " (AS %s)", pItem->zAlias);
+          sqlite3XPrintf(&x, " (AS %s)", pItem->zAlias);
         }
         if( pItem->fg.jointype & JT_LEFT ){
-          sqlite3XPrintf(&x, 0, " LEFT-JOIN");
+          sqlite3XPrintf(&x, " LEFT-JOIN");
         }
         sqlite3StrAccumFinish(&x);
         sqlite3TreeViewItem(pView, zLine, i<p->pSrc->nSrc-1); 
@@ -24798,7 +25022,7 @@ SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemTranslate(Mem *pMem, u8 desired
 
   c = pMem->flags;
   sqlite3VdbeMemRelease(pMem);
-  pMem->flags = MEM_Str|MEM_Term|(c&MEM_AffMask);
+  pMem->flags = MEM_Str|MEM_Term|(c&(MEM_AffMask|MEM_Subtype));
   pMem->enc = desiredEnc;
   pMem->z = (char*)zOut;
   pMem->zMalloc = pMem->z;
@@ -25249,6 +25473,14 @@ SQLITE_PRIVATE int sqlite3Dequote(char *z){
   return j;
 }
 
+/*
+** Generate a Token object from a string
+*/
+SQLITE_PRIVATE void sqlite3TokenInit(Token *p, char *z){
+  p->z = z;
+  p->n = sqlite3Strlen30(z);
+}
+
 /* Convenient short-hand */
 #define UpperToLower sqlite3UpperToLower
 
@@ -26157,7 +26389,7 @@ SQLITE_PRIVATE void *sqlite3HexToBlob(sqlite3 *db, const char *z, int n){
   char *zBlob;
   int i;
 
-  zBlob = (char *)sqlite3DbMallocRaw(db, n/2 + 1);
+  zBlob = (char *)sqlite3DbMallocRawNN(db, n/2 + 1);
   n--;
   if( zBlob ){
     for(i=0; i<n; i+=2){
@@ -26695,82 +26927,83 @@ SQLITE_PRIVATE void *sqlite3HashInsert(Hash *pH, const char *pKey, void *data){
 # define OpHelp(X)
 #endif
 SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
- static const char *const azName[] = { "?",
-    /*   1 */ "Savepoint"        OpHelp(""),
-    /*   2 */ "AutoCommit"       OpHelp(""),
-    /*   3 */ "Transaction"      OpHelp(""),
-    /*   4 */ "SorterNext"       OpHelp(""),
-    /*   5 */ "PrevIfOpen"       OpHelp(""),
-    /*   6 */ "NextIfOpen"       OpHelp(""),
-    /*   7 */ "Prev"             OpHelp(""),
-    /*   8 */ "Next"             OpHelp(""),
-    /*   9 */ "Checkpoint"       OpHelp(""),
-    /*  10 */ "JournalMode"      OpHelp(""),
-    /*  11 */ "Vacuum"           OpHelp(""),
-    /*  12 */ "VFilter"          OpHelp("iplan=r[P3] zplan='P4'"),
-    /*  13 */ "VUpdate"          OpHelp("data=r[P3@P2]"),
-    /*  14 */ "Goto"             OpHelp(""),
-    /*  15 */ "Gosub"            OpHelp(""),
-    /*  16 */ "Return"           OpHelp(""),
-    /*  17 */ "InitCoroutine"    OpHelp(""),
-    /*  18 */ "EndCoroutine"     OpHelp(""),
+ static const char *const azName[] = {
+    /*   0 */ "Savepoint"        OpHelp(""),
+    /*   1 */ "AutoCommit"       OpHelp(""),
+    /*   2 */ "Transaction"      OpHelp(""),
+    /*   3 */ "SorterNext"       OpHelp(""),
+    /*   4 */ "PrevIfOpen"       OpHelp(""),
+    /*   5 */ "NextIfOpen"       OpHelp(""),
+    /*   6 */ "Prev"             OpHelp(""),
+    /*   7 */ "Next"             OpHelp(""),
+    /*   8 */ "Checkpoint"       OpHelp(""),
+    /*   9 */ "JournalMode"      OpHelp(""),
+    /*  10 */ "Vacuum"           OpHelp(""),
+    /*  11 */ "VFilter"          OpHelp("iplan=r[P3] zplan='P4'"),
+    /*  12 */ "VUpdate"          OpHelp("data=r[P3@P2]"),
+    /*  13 */ "Goto"             OpHelp(""),
+    /*  14 */ "Gosub"            OpHelp(""),
+    /*  15 */ "Return"           OpHelp(""),
+    /*  16 */ "InitCoroutine"    OpHelp(""),
+    /*  17 */ "EndCoroutine"     OpHelp(""),
+    /*  18 */ "Yield"            OpHelp(""),
     /*  19 */ "Not"              OpHelp("r[P2]= !r[P1]"),
-    /*  20 */ "Yield"            OpHelp(""),
-    /*  21 */ "HaltIfNull"       OpHelp("if r[P3]=null halt"),
-    /*  22 */ "Halt"             OpHelp(""),
-    /*  23 */ "Integer"          OpHelp("r[P2]=P1"),
-    /*  24 */ "Int64"            OpHelp("r[P2]=P4"),
-    /*  25 */ "String"           OpHelp("r[P2]='P4' (len=P1)"),
-    /*  26 */ "Null"             OpHelp("r[P2..P3]=NULL"),
-    /*  27 */ "SoftNull"         OpHelp("r[P1]=NULL"),
-    /*  28 */ "Blob"             OpHelp("r[P2]=P4 (len=P1)"),
-    /*  29 */ "Variable"         OpHelp("r[P2]=parameter(P1,P4)"),
-    /*  30 */ "Move"             OpHelp("r[P2@P3]=r[P1@P3]"),
-    /*  31 */ "Copy"             OpHelp("r[P2@P3+1]=r[P1@P3+1]"),
-    /*  32 */ "SCopy"            OpHelp("r[P2]=r[P1]"),
-    /*  33 */ "IntCopy"          OpHelp("r[P2]=r[P1]"),
-    /*  34 */ "ResultRow"        OpHelp("output=r[P1@P2]"),
-    /*  35 */ "CollSeq"          OpHelp(""),
-    /*  36 */ "Function0"        OpHelp("r[P3]=func(r[P2@P5])"),
-    /*  37 */ "Function"         OpHelp("r[P3]=func(r[P2@P5])"),
-    /*  38 */ "AddImm"           OpHelp("r[P1]=r[P1]+P2"),
-    /*  39 */ "MustBeInt"        OpHelp(""),
-    /*  40 */ "RealAffinity"     OpHelp(""),
-    /*  41 */ "Cast"             OpHelp("affinity(r[P1])"),
-    /*  42 */ "Permutation"      OpHelp(""),
-    /*  43 */ "Compare"          OpHelp("r[P1@P3] <-> r[P2@P3]"),
-    /*  44 */ "Jump"             OpHelp(""),
-    /*  45 */ "Once"             OpHelp(""),
-    /*  46 */ "If"               OpHelp(""),
-    /*  47 */ "IfNot"            OpHelp(""),
-    /*  48 */ "Column"           OpHelp("r[P3]=PX"),
-    /*  49 */ "Affinity"         OpHelp("affinity(r[P1@P2])"),
-    /*  50 */ "MakeRecord"       OpHelp("r[P3]=mkrec(r[P1@P2])"),
-    /*  51 */ "Count"            OpHelp("r[P2]=count()"),
-    /*  52 */ "ReadCookie"       OpHelp(""),
-    /*  53 */ "SetCookie"        OpHelp(""),
-    /*  54 */ "ReopenIdx"        OpHelp("root=P2 iDb=P3"),
-    /*  55 */ "OpenRead"         OpHelp("root=P2 iDb=P3"),
-    /*  56 */ "OpenWrite"        OpHelp("root=P2 iDb=P3"),
-    /*  57 */ "OpenAutoindex"    OpHelp("nColumn=P2"),
-    /*  58 */ "OpenEphemeral"    OpHelp("nColumn=P2"),
-    /*  59 */ "SorterOpen"       OpHelp(""),
-    /*  60 */ "SequenceTest"     OpHelp("if( cursor[P1].ctr++ ) pc = P2"),
-    /*  61 */ "OpenPseudo"       OpHelp("P3 columns in r[P2]"),
-    /*  62 */ "Close"            OpHelp(""),
-    /*  63 */ "ColumnsUsed"      OpHelp(""),
-    /*  64 */ "SeekLT"           OpHelp("key=r[P3@P4]"),
-    /*  65 */ "SeekLE"           OpHelp("key=r[P3@P4]"),
-    /*  66 */ "SeekGE"           OpHelp("key=r[P3@P4]"),
-    /*  67 */ "SeekGT"           OpHelp("key=r[P3@P4]"),
-    /*  68 */ "Seek"             OpHelp("intkey=r[P2]"),
-    /*  69 */ "NoConflict"       OpHelp("key=r[P3@P4]"),
-    /*  70 */ "NotFound"         OpHelp("key=r[P3@P4]"),
+    /*  20 */ "HaltIfNull"       OpHelp("if r[P3]=null halt"),
+    /*  21 */ "Halt"             OpHelp(""),
+    /*  22 */ "Integer"          OpHelp("r[P2]=P1"),
+    /*  23 */ "Int64"            OpHelp("r[P2]=P4"),
+    /*  24 */ "String"           OpHelp("r[P2]='P4' (len=P1)"),
+    /*  25 */ "Null"             OpHelp("r[P2..P3]=NULL"),
+    /*  26 */ "SoftNull"         OpHelp("r[P1]=NULL"),
+    /*  27 */ "Blob"             OpHelp("r[P2]=P4 (len=P1)"),
+    /*  28 */ "Variable"         OpHelp("r[P2]=parameter(P1,P4)"),
+    /*  29 */ "Move"             OpHelp("r[P2@P3]=r[P1@P3]"),
+    /*  30 */ "Copy"             OpHelp("r[P2@P3+1]=r[P1@P3+1]"),
+    /*  31 */ "SCopy"            OpHelp("r[P2]=r[P1]"),
+    /*  32 */ "IntCopy"          OpHelp("r[P2]=r[P1]"),
+    /*  33 */ "ResultRow"        OpHelp("output=r[P1@P2]"),
+    /*  34 */ "CollSeq"          OpHelp(""),
+    /*  35 */ "Function0"        OpHelp("r[P3]=func(r[P2@P5])"),
+    /*  36 */ "Function"         OpHelp("r[P3]=func(r[P2@P5])"),
+    /*  37 */ "AddImm"           OpHelp("r[P1]=r[P1]+P2"),
+    /*  38 */ "MustBeInt"        OpHelp(""),
+    /*  39 */ "RealAffinity"     OpHelp(""),
+    /*  40 */ "Cast"             OpHelp("affinity(r[P1])"),
+    /*  41 */ "Permutation"      OpHelp(""),
+    /*  42 */ "Compare"          OpHelp("r[P1@P3] <-> r[P2@P3]"),
+    /*  43 */ "Jump"             OpHelp(""),
+    /*  44 */ "Once"             OpHelp(""),
+    /*  45 */ "If"               OpHelp(""),
+    /*  46 */ "IfNot"            OpHelp(""),
+    /*  47 */ "Column"           OpHelp("r[P3]=PX"),
+    /*  48 */ "Affinity"         OpHelp("affinity(r[P1@P2])"),
+    /*  49 */ "MakeRecord"       OpHelp("r[P3]=mkrec(r[P1@P2])"),
+    /*  50 */ "Count"            OpHelp("r[P2]=count()"),
+    /*  51 */ "ReadCookie"       OpHelp(""),
+    /*  52 */ "SetCookie"        OpHelp(""),
+    /*  53 */ "ReopenIdx"        OpHelp("root=P2 iDb=P3"),
+    /*  54 */ "OpenRead"         OpHelp("root=P2 iDb=P3"),
+    /*  55 */ "OpenWrite"        OpHelp("root=P2 iDb=P3"),
+    /*  56 */ "OpenAutoindex"    OpHelp("nColumn=P2"),
+    /*  57 */ "OpenEphemeral"    OpHelp("nColumn=P2"),
+    /*  58 */ "SorterOpen"       OpHelp(""),
+    /*  59 */ "SequenceTest"     OpHelp("if( cursor[P1].ctr++ ) pc = P2"),
+    /*  60 */ "OpenPseudo"       OpHelp("P3 columns in r[P2]"),
+    /*  61 */ "Close"            OpHelp(""),
+    /*  62 */ "ColumnsUsed"      OpHelp(""),
+    /*  63 */ "SeekLT"           OpHelp("key=r[P3@P4]"),
+    /*  64 */ "SeekLE"           OpHelp("key=r[P3@P4]"),
+    /*  65 */ "SeekGE"           OpHelp("key=r[P3@P4]"),
+    /*  66 */ "SeekGT"           OpHelp("key=r[P3@P4]"),
+    /*  67 */ "NoConflict"       OpHelp("key=r[P3@P4]"),
+    /*  68 */ "NotFound"         OpHelp("key=r[P3@P4]"),
+    /*  69 */ "Found"            OpHelp("key=r[P3@P4]"),
+    /*  70 */ "NotExists"        OpHelp("intkey=r[P3]"),
     /*  71 */ "Or"               OpHelp("r[P3]=(r[P1] || r[P2])"),
     /*  72 */ "And"              OpHelp("r[P3]=(r[P1] && r[P2])"),
-    /*  73 */ "Found"            OpHelp("key=r[P3@P4]"),
-    /*  74 */ "NotExists"        OpHelp("intkey=r[P3]"),
-    /*  75 */ "Sequence"         OpHelp("r[P2]=cursor[P1].ctr++"),
+    /*  73 */ "Sequence"         OpHelp("r[P2]=cursor[P1].ctr++"),
+    /*  74 */ "NewRowid"         OpHelp("r[P2]=rowid"),
+    /*  75 */ "Insert"           OpHelp("intkey=r[P3] data=r[P2]"),
     /*  76 */ "IsNull"           OpHelp("if r[P1]==NULL goto P2"),
     /*  77 */ "NotNull"          OpHelp("if r[P1]!=NULL goto P2"),
     /*  78 */ "Ne"               OpHelp("if r[P1]!=r[P3] goto P2"),
@@ -26779,7 +27012,7 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
     /*  81 */ "Le"               OpHelp("if r[P1]<=r[P3] goto P2"),
     /*  82 */ "Lt"               OpHelp("if r[P1]<r[P3] goto P2"),
     /*  83 */ "Ge"               OpHelp("if r[P1]>=r[P3] goto P2"),
-    /*  84 */ "NewRowid"         OpHelp("r[P2]=rowid"),
+    /*  84 */ "InsertInt"        OpHelp("intkey=P3 data=r[P2]"),
     /*  85 */ "BitAnd"           OpHelp("r[P3]=r[P1]&r[P2]"),
     /*  86 */ "BitOr"            OpHelp("r[P3]=r[P1]|r[P2]"),
     /*  87 */ "ShiftLeft"        OpHelp("r[P3]=r[P2]<<r[P1]"),
@@ -26790,74 +27023,73 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
     /*  92 */ "Divide"           OpHelp("r[P3]=r[P2]/r[P1]"),
     /*  93 */ "Remainder"        OpHelp("r[P3]=r[P2]%r[P1]"),
     /*  94 */ "Concat"           OpHelp("r[P3]=r[P2]+r[P1]"),
-    /*  95 */ "Insert"           OpHelp("intkey=r[P3] data=r[P2]"),
+    /*  95 */ "Delete"           OpHelp(""),
     /*  96 */ "BitNot"           OpHelp("r[P1]= ~r[P1]"),
     /*  97 */ "String8"          OpHelp("r[P2]='P4'"),
-    /*  98 */ "InsertInt"        OpHelp("intkey=P3 data=r[P2]"),
-    /*  99 */ "Delete"           OpHelp(""),
-    /* 100 */ "ResetCount"       OpHelp(""),
-    /* 101 */ "SorterCompare"    OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"),
-    /* 102 */ "SorterData"       OpHelp("r[P2]=data"),
-    /* 103 */ "RowKey"           OpHelp("r[P2]=key"),
-    /* 104 */ "RowData"          OpHelp("r[P2]=data"),
-    /* 105 */ "Rowid"            OpHelp("r[P2]=rowid"),
-    /* 106 */ "NullRow"          OpHelp(""),
-    /* 107 */ "Last"             OpHelp(""),
-    /* 108 */ "SorterSort"       OpHelp(""),
-    /* 109 */ "Sort"             OpHelp(""),
-    /* 110 */ "Rewind"           OpHelp(""),
-    /* 111 */ "SorterInsert"     OpHelp(""),
-    /* 112 */ "IdxInsert"        OpHelp("key=r[P2]"),
-    /* 113 */ "IdxDelete"        OpHelp("key=r[P2@P3]"),
-    /* 114 */ "IdxRowid"         OpHelp("r[P2]=rowid"),
-    /* 115 */ "IdxLE"            OpHelp("key=r[P3@P4]"),
-    /* 116 */ "IdxGT"            OpHelp("key=r[P3@P4]"),
-    /* 117 */ "IdxLT"            OpHelp("key=r[P3@P4]"),
-    /* 118 */ "IdxGE"            OpHelp("key=r[P3@P4]"),
-    /* 119 */ "Destroy"          OpHelp(""),
-    /* 120 */ "Clear"            OpHelp(""),
-    /* 121 */ "ResetSorter"      OpHelp(""),
-    /* 122 */ "CreateIndex"      OpHelp("r[P2]=root iDb=P1"),
-    /* 123 */ "CreateTable"      OpHelp("r[P2]=root iDb=P1"),
-    /* 124 */ "ParseSchema"      OpHelp(""),
-    /* 125 */ "LoadAnalysis"     OpHelp(""),
-    /* 126 */ "DropTable"        OpHelp(""),
-    /* 127 */ "DropIndex"        OpHelp(""),
-    /* 128 */ "DropTrigger"      OpHelp(""),
-    /* 129 */ "IntegrityCk"      OpHelp(""),
-    /* 130 */ "RowSetAdd"        OpHelp("rowset(P1)=r[P2]"),
-    /* 131 */ "RowSetRead"       OpHelp("r[P3]=rowset(P1)"),
-    /* 132 */ "RowSetTest"       OpHelp("if r[P3] in rowset(P1) goto P2"),
+    /*  98 */ "ResetCount"       OpHelp(""),
+    /*  99 */ "SorterCompare"    OpHelp("if key(P1)!=trim(r[P3],P4) goto P2"),
+    /* 100 */ "SorterData"       OpHelp("r[P2]=data"),
+    /* 101 */ "RowKey"           OpHelp("r[P2]=key"),
+    /* 102 */ "RowData"          OpHelp("r[P2]=data"),
+    /* 103 */ "Rowid"            OpHelp("r[P2]=rowid"),
+    /* 104 */ "NullRow"          OpHelp(""),
+    /* 105 */ "Last"             OpHelp(""),
+    /* 106 */ "SorterSort"       OpHelp(""),
+    /* 107 */ "Sort"             OpHelp(""),
+    /* 108 */ "Rewind"           OpHelp(""),
+    /* 109 */ "SorterInsert"     OpHelp(""),
+    /* 110 */ "IdxInsert"        OpHelp("key=r[P2]"),
+    /* 111 */ "IdxDelete"        OpHelp("key=r[P2@P3]"),
+    /* 112 */ "Seek"             OpHelp("Move P3 to P1.rowid"),
+    /* 113 */ "IdxRowid"         OpHelp("r[P2]=rowid"),
+    /* 114 */ "IdxLE"            OpHelp("key=r[P3@P4]"),
+    /* 115 */ "IdxGT"            OpHelp("key=r[P3@P4]"),
+    /* 116 */ "IdxLT"            OpHelp("key=r[P3@P4]"),
+    /* 117 */ "IdxGE"            OpHelp("key=r[P3@P4]"),
+    /* 118 */ "Destroy"          OpHelp(""),
+    /* 119 */ "Clear"            OpHelp(""),
+    /* 120 */ "ResetSorter"      OpHelp(""),
+    /* 121 */ "CreateIndex"      OpHelp("r[P2]=root iDb=P1"),
+    /* 122 */ "CreateTable"      OpHelp("r[P2]=root iDb=P1"),
+    /* 123 */ "ParseSchema"      OpHelp(""),
+    /* 124 */ "LoadAnalysis"     OpHelp(""),
+    /* 125 */ "DropTable"        OpHelp(""),
+    /* 126 */ "DropIndex"        OpHelp(""),
+    /* 127 */ "DropTrigger"      OpHelp(""),
+    /* 128 */ "IntegrityCk"      OpHelp(""),
+    /* 129 */ "RowSetAdd"        OpHelp("rowset(P1)=r[P2]"),
+    /* 130 */ "RowSetRead"       OpHelp("r[P3]=rowset(P1)"),
+    /* 131 */ "RowSetTest"       OpHelp("if r[P3] in rowset(P1) goto P2"),
+    /* 132 */ "Program"          OpHelp(""),
     /* 133 */ "Real"             OpHelp("r[P2]=P4"),
-    /* 134 */ "Program"          OpHelp(""),
-    /* 135 */ "Param"            OpHelp(""),
-    /* 136 */ "FkCounter"        OpHelp("fkctr[P1]+=P2"),
-    /* 137 */ "FkIfZero"         OpHelp("if fkctr[P1]==0 goto P2"),
-    /* 138 */ "MemMax"           OpHelp("r[P1]=max(r[P1],r[P2])"),
-    /* 139 */ "IfPos"            OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"),
-    /* 140 */ "SetIfNotPos"      OpHelp("if r[P1]<=0 then r[P2]=P3"),
-    /* 141 */ "IfNotZero"        OpHelp("if r[P1]!=0 then r[P1]-=P3, goto P2"),
-    /* 142 */ "DecrJumpZero"     OpHelp("if (--r[P1])==0 goto P2"),
-    /* 143 */ "JumpZeroIncr"     OpHelp("if (r[P1]++)==0 ) goto P2"),
-    /* 144 */ "AggStep0"         OpHelp("accum=r[P3] step(r[P2@P5])"),
-    /* 145 */ "AggStep"          OpHelp("accum=r[P3] step(r[P2@P5])"),
-    /* 146 */ "AggFinal"         OpHelp("accum=r[P1] N=P2"),
-    /* 147 */ "IncrVacuum"       OpHelp(""),
-    /* 148 */ "Expire"           OpHelp(""),
-    /* 149 */ "TableLock"        OpHelp("iDb=P1 root=P2 write=P3"),
-    /* 150 */ "VBegin"           OpHelp(""),
-    /* 151 */ "VCreate"          OpHelp(""),
-    /* 152 */ "VDestroy"         OpHelp(""),
-    /* 153 */ "VOpen"            OpHelp(""),
-    /* 154 */ "VColumn"          OpHelp("r[P3]=vcolumn(P2)"),
-    /* 155 */ "VNext"            OpHelp(""),
-    /* 156 */ "VRename"          OpHelp(""),
-    /* 157 */ "Pagecount"        OpHelp(""),
-    /* 158 */ "MaxPgcnt"         OpHelp(""),
-    /* 159 */ "Init"             OpHelp("Start at P2"),
-    /* 160 */ "CursorHint"       OpHelp(""),
-    /* 161 */ "Noop"             OpHelp(""),
-    /* 162 */ "Explain"          OpHelp(""),
+    /* 134 */ "Param"            OpHelp(""),
+    /* 135 */ "FkCounter"        OpHelp("fkctr[P1]+=P2"),
+    /* 136 */ "FkIfZero"         OpHelp("if fkctr[P1]==0 goto P2"),
+    /* 137 */ "MemMax"           OpHelp("r[P1]=max(r[P1],r[P2])"),
+    /* 138 */ "IfPos"            OpHelp("if r[P1]>0 then r[P1]-=P3, goto P2"),
+    /* 139 */ "OffsetLimit"      OpHelp("if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)"),
+    /* 140 */ "IfNotZero"        OpHelp("if r[P1]!=0 then r[P1]-=P3, goto P2"),
+    /* 141 */ "DecrJumpZero"     OpHelp("if (--r[P1])==0 goto P2"),
+    /* 142 */ "JumpZeroIncr"     OpHelp("if (r[P1]++)==0 ) goto P2"),
+    /* 143 */ "AggStep0"         OpHelp("accum=r[P3] step(r[P2@P5])"),
+    /* 144 */ "AggStep"          OpHelp("accum=r[P3] step(r[P2@P5])"),
+    /* 145 */ "AggFinal"         OpHelp("accum=r[P1] N=P2"),
+    /* 146 */ "IncrVacuum"       OpHelp(""),
+    /* 147 */ "Expire"           OpHelp(""),
+    /* 148 */ "TableLock"        OpHelp("iDb=P1 root=P2 write=P3"),
+    /* 149 */ "VBegin"           OpHelp(""),
+    /* 150 */ "VCreate"          OpHelp(""),
+    /* 151 */ "VDestroy"         OpHelp(""),
+    /* 152 */ "VOpen"            OpHelp(""),
+    /* 153 */ "VColumn"          OpHelp("r[P3]=vcolumn(P2)"),
+    /* 154 */ "VNext"            OpHelp(""),
+    /* 155 */ "VRename"          OpHelp(""),
+    /* 156 */ "Pagecount"        OpHelp(""),
+    /* 157 */ "MaxPgcnt"         OpHelp(""),
+    /* 158 */ "Init"             OpHelp("Start at P2"),
+    /* 159 */ "CursorHint"       OpHelp(""),
+    /* 160 */ "Noop"             OpHelp(""),
+    /* 161 */ "Explain"          OpHelp(""),
   };
   return azName[i];
 }
@@ -27016,6 +27248,11 @@ SQLITE_PRIVATE const char *sqlite3OpcodeName(int i){
 */
 #define MAX_PATHNAME 512
 
+/*
+** Maximum supported symbolic links
+*/
+#define SQLITE_MAX_SYMLINKS 100
+
 /* Always cast the getpid() return type for compatibility with
 ** kernel modules in VxWorks. */
 #define osGetpid(X) (pid_t)getpid()
@@ -27168,8 +27405,8 @@ static pid_t randomnessPid = 0;
 */
 #ifdef SQLITE_PERFORMANCE_TRACE
 
-/* 
-** hwtime.h contains inline assembler code for implementing 
+/*
+** hwtime.h contains inline assembler code for implementing
 ** high-performance timing routines.
 */
 /************** Include hwtime.h in the middle of os_common.h ****************/
@@ -27279,14 +27516,14 @@ static sqlite_uint64 g_elapsed;
 ** of code will give us the ability to simulate a disk I/O error.  This
 ** is used for testing the I/O recovery logic.
 */
-#ifdef SQLITE_TEST
-SQLITE_API int sqlite3_io_error_hit = 0;            /* Total number of I/O Errors */
-SQLITE_API int sqlite3_io_error_hardhit = 0;        /* Number of non-benign errors */
-SQLITE_API int sqlite3_io_error_pending = 0;        /* Count down to first I/O error */
-SQLITE_API int sqlite3_io_error_persist = 0;        /* True if I/O errors persist */
-SQLITE_API int sqlite3_io_error_benign = 0;         /* True if errors are benign */
-SQLITE_API int sqlite3_diskfull_pending = 0;
-SQLITE_API int sqlite3_diskfull = 0;
+#if defined(SQLITE_TEST)
+SQLITE_API extern int sqlite3_io_error_hit;
+SQLITE_API extern int sqlite3_io_error_hardhit;
+SQLITE_API extern int sqlite3_io_error_pending;
+SQLITE_API extern int sqlite3_io_error_persist;
+SQLITE_API extern int sqlite3_io_error_benign;
+SQLITE_API extern int sqlite3_diskfull_pending;
+SQLITE_API extern int sqlite3_diskfull;
 #define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X)
 #define SimulateIOError(CODE)  \
   if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \
@@ -27312,17 +27549,17 @@ static void local_ioerr(){
 #define SimulateIOErrorBenign(X)
 #define SimulateIOError(A)
 #define SimulateDiskfullError(A)
-#endif
+#endif /* defined(SQLITE_TEST) */
 
 /*
 ** When testing, keep a count of the number of open files.
 */
-#ifdef SQLITE_TEST
-SQLITE_API int sqlite3_open_file_count = 0;
+#if defined(SQLITE_TEST)
+SQLITE_API extern int sqlite3_open_file_count;
 #define OpenCounter(X)  sqlite3_open_file_count+=(X)
 #else
 #define OpenCounter(X)
-#endif
+#endif /* defined(SQLITE_TEST) */
 
 #endif /* !defined(_OS_COMMON_H_) */
 
@@ -27495,33 +27732,57 @@ static struct unix_syscall {
   { "rmdir",        (sqlite3_syscall_ptr)rmdir,           0 },
 #define osRmdir     ((int(*)(const char*))aSyscall[19].pCurrent)
 
+#if defined(HAVE_FCHOWN)
   { "fchown",       (sqlite3_syscall_ptr)fchown,          0 },
+#else
+  { "fchown",       (sqlite3_syscall_ptr)0,               0 },
+#endif
 #define osFchown    ((int(*)(int,uid_t,gid_t))aSyscall[20].pCurrent)
 
   { "geteuid",      (sqlite3_syscall_ptr)geteuid,         0 },
 #define osGeteuid   ((uid_t(*)(void))aSyscall[21].pCurrent)
 
 #if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0
-  { "mmap",       (sqlite3_syscall_ptr)mmap,     0 },
+  { "mmap",         (sqlite3_syscall_ptr)mmap,            0 },
+#else
+  { "mmap",         (sqlite3_syscall_ptr)0,               0 },
+#endif
 #define osMmap ((void*(*)(void*,size_t,int,int,int,off_t))aSyscall[22].pCurrent)
 
+#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0
   { "munmap",       (sqlite3_syscall_ptr)munmap,          0 },
+#else
+  { "munmap",       (sqlite3_syscall_ptr)0,               0 },
+#endif
 #define osMunmap ((void*(*)(void*,size_t))aSyscall[23].pCurrent)
 
-#if HAVE_MREMAP
+#if HAVE_MREMAP && (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0)
   { "mremap",       (sqlite3_syscall_ptr)mremap,          0 },
 #else
   { "mremap",       (sqlite3_syscall_ptr)0,               0 },
 #endif
 #define osMremap ((void*(*)(void*,size_t,size_t,int,...))aSyscall[24].pCurrent)
 
+#if !defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0
   { "getpagesize",  (sqlite3_syscall_ptr)unixGetpagesize, 0 },
+#else
+  { "getpagesize",  (sqlite3_syscall_ptr)0,               0 },
+#endif
 #define osGetpagesize ((int(*)(void))aSyscall[25].pCurrent)
 
+#if defined(HAVE_READLINK)
   { "readlink",     (sqlite3_syscall_ptr)readlink,        0 },
+#else
+  { "readlink",     (sqlite3_syscall_ptr)0,               0 },
+#endif
 #define osReadlink ((ssize_t(*)(const char*,char*,size_t))aSyscall[26].pCurrent)
 
+#if defined(HAVE_LSTAT)
+  { "lstat",         (sqlite3_syscall_ptr)lstat,          0 },
+#else
+  { "lstat",         (sqlite3_syscall_ptr)0,              0 },
 #endif
+#define osLstat      ((int(*)(const char*,struct stat*))aSyscall[27].pCurrent)
 
 }; /* End of the overrideable system calls */
 
@@ -27532,10 +27793,10 @@ static struct unix_syscall {
 ** we are not running as root.
 */
 static int robustFchown(int fd, uid_t uid, gid_t gid){
-#if OS_VXWORKS
-  return 0;
-#else
+#if defined(HAVE_FCHOWN)
   return osGeteuid() ? 0 : osFchown(fd,uid,gid);
+#else
+  return 0;
 #endif
 }
 
@@ -32923,12 +33184,7 @@ static int unixDelete(
     int fd;
     rc = osOpenDirectory(zPath, &fd);
     if( rc==SQLITE_OK ){
-#if OS_VXWORKS
-      if( fsync(fd)==-1 )
-#else
-      if( fsync(fd) )
-#endif
-      {
+      if( full_fsync(fd,0,0) ){
         rc = unixLogError(SQLITE_IOERR_DIR_FSYNC, "fsync", zPath);
       }
       robust_close(0, fd, __LINE__);
@@ -32974,6 +33230,32 @@ static int unixAccess(
   return SQLITE_OK;
 }
 
+/*
+**
+*/
+static int mkFullPathname(
+  const char *zPath,              /* Input path */
+  char *zOut,                     /* Output buffer */
+  int nOut                        /* Allocated size of buffer zOut */
+){
+  int nPath = sqlite3Strlen30(zPath);
+  int iOff = 0;
+  if( zPath[0]!='/' ){
+    if( osGetcwd(zOut, nOut-2)==0 ){
+      return unixLogError(SQLITE_CANTOPEN_BKPT, "getcwd", zPath);
+    }
+    iOff = sqlite3Strlen30(zOut);
+    zOut[iOff++] = '/';
+  }
+  if( (iOff+nPath+1)>nOut ){
+    /* SQLite assumes that xFullPathname() nul-terminates the output buffer
+    ** even if it returns an error.  */
+    zOut[iOff] = '\0';
+    return SQLITE_CANTOPEN_BKPT;
+  }
+  sqlite3_snprintf(nOut-iOff, &zOut[iOff], "%s", zPath);
+  return SQLITE_OK;
+}
 
 /*
 ** Turn a relative pathname into a full pathname. The relative path
@@ -32990,7 +33272,17 @@ static int unixFullPathname(
   int nOut,                     /* Size of output buffer in bytes */
   char *zOut                    /* Output buffer */
 ){
+#if !defined(HAVE_READLINK) || !defined(HAVE_LSTAT)
+  return mkFullPathname(zPath, zOut, nOut);
+#else
+  int rc = SQLITE_OK;
   int nByte;
+  int nLink = 1;                /* Number of symbolic links followed so far */
+  const char *zIn = zPath;      /* Input path for each iteration of loop */
+  char *zDel = 0;
+
+  assert( pVfs->mxPathname==MAX_PATHNAME );
+  UNUSED_PARAMETER(pVfs);
 
   /* It's odd to simulate an io-error here, but really this is just
   ** using the io-error infrastructure to test that SQLite handles this
@@ -32999,58 +33291,62 @@ static int unixFullPathname(
   */
   SimulateIOError( return SQLITE_ERROR );
 
-  assert( pVfs->mxPathname==MAX_PATHNAME );
-  UNUSED_PARAMETER(pVfs);
+  do {
 
-  /* Attempt to resolve the path as if it were a symbolic link. If it is
-  ** a symbolic link, the resolved path is stored in buffer zOut[]. Or, if
-  ** the identified file is not a symbolic link or does not exist, then
-  ** zPath is copied directly into zOut. Either way, nByte is left set to
-  ** the size of the string copied into zOut[] in bytes.  */
-  nByte = osReadlink(zPath, zOut, nOut-1);
-  if( nByte<0 ){
-    if( errno!=EINVAL && errno!=ENOENT ){
-      return unixLogError(SQLITE_CANTOPEN_BKPT, "readlink", zPath);
+    /* Call stat() on path zIn. Set bLink to true if the path is a symbolic
+    ** link, or false otherwise.  */
+    int bLink = 0;
+    struct stat buf;
+    if( osLstat(zIn, &buf)!=0 ){
+      if( errno!=ENOENT ){
+        rc = unixLogError(SQLITE_CANTOPEN_BKPT, "lstat", zIn);
+      }
+    }else{
+      bLink = S_ISLNK(buf.st_mode);
     }
-    sqlite3_snprintf(nOut, zOut, "%s", zPath);
-    nByte = sqlite3Strlen30(zOut);
-  }else{
-    zOut[nByte] = '\0';
-  }
 
-  /* If buffer zOut[] now contains an absolute path there is nothing more
-  ** to do. If it contains a relative path, do the following:
-  **
-  **   * move the relative path string so that it is at the end of th
-  **     zOut[] buffer.
-  **   * Call getcwd() to read the path of the current working directory 
-  **     into the start of the zOut[] buffer.
-  **   * Append a '/' character to the cwd string and move the 
-  **     relative path back within the buffer so that it immediately 
-  **     follows the '/'.
-  **
-  ** This code is written so that if the combination of the CWD and relative
-  ** path are larger than the allocated size of zOut[] the CWD is silently
-  ** truncated to make it fit. This is Ok, as SQLite refuses to open any
-  ** file for which this function returns a full path larger than (nOut-8)
-  ** bytes in size.  */
-  testcase( nByte==nOut-5 );
-  testcase( nByte==nOut-4 );
-  if( zOut[0]!='/' && nByte<nOut-4 ){
-    int nCwd;
-    int nRem = nOut-nByte-1;
-    memmove(&zOut[nRem], zOut, nByte+1);
-    zOut[nRem-1] = '\0';
-    if( osGetcwd(zOut, nRem-1)==0 ){
-      return unixLogError(SQLITE_CANTOPEN_BKPT, "getcwd", zPath);
+    if( bLink ){
+      if( zDel==0 ){
+        zDel = sqlite3_malloc(nOut);
+        if( zDel==0 ) rc = SQLITE_NOMEM;
+      }else if( ++nLink>SQLITE_MAX_SYMLINKS ){
+        rc = SQLITE_CANTOPEN_BKPT;
+      }
+
+      if( rc==SQLITE_OK ){
+        nByte = osReadlink(zIn, zDel, nOut-1);
+        if( nByte<0 ){
+          rc = unixLogError(SQLITE_CANTOPEN_BKPT, "readlink", zIn);
+        }else{
+          if( zDel[0]!='/' ){
+            int n;
+            for(n = sqlite3Strlen30(zIn); n>0 && zIn[n-1]!='/'; n--);
+            if( nByte+n+1>nOut ){
+              rc = SQLITE_CANTOPEN_BKPT;
+            }else{
+              memmove(&zDel[n], zDel, nByte+1);
+              memcpy(zDel, zIn, n);
+              nByte += n;
+            }
+          }
+          zDel[nByte] = '\0';
+        }
+      }
+
+      zIn = zDel;
     }
-    nCwd = sqlite3Strlen30(zOut);
-    assert( nCwd<=nRem-1 );
-    zOut[nCwd] = '/';
-    memmove(&zOut[nCwd+1], &zOut[nRem], nByte+1);
-  }
 
-  return SQLITE_OK;
+    assert( rc!=SQLITE_OK || zIn!=zOut || zIn[0]=='/' );
+    if( rc==SQLITE_OK && zIn!=zOut ){
+      rc = mkFullPathname(zIn, zOut, nOut);
+    }
+    if( bLink==0 ) break;
+    zIn = zOut;
+  }while( rc==SQLITE_OK );
+
+  sqlite3_free(zDel);
+  return rc;
+#endif   /* HAVE_READLINK && HAVE_LSTAT */
 }
 
 
@@ -33232,7 +33528,7 @@ static int unixCurrentTimeInt64(sqlite3_vfs *NotUsed, sqlite3_int64 *piNow){
   return rc;
 }
 
-#if 0 /* Not used */
+#ifndef SQLITE_OMIT_DEPRECATED
 /*
 ** Find the current time (in Universal Coordinated Time).  Write the
 ** current time and date as a Julian Day number into *prNow and
@@ -33250,7 +33546,7 @@ static int unixCurrentTime(sqlite3_vfs *NotUsed, double *prNow){
 # define unixCurrentTime 0
 #endif
 
-#if 0  /* Not used */
+#ifndef SQLITE_OMIT_DEPRECATED
 /*
 ** We added the xGetLastError() method with the intention of providing
 ** better low-level error messages when operating-system problems come up
@@ -33932,7 +34228,7 @@ static int proxyTakeConch(unixFile *pFile){
         writeSize = PROXY_PATHINDEX + strlen(&writeBuffer[PROXY_PATHINDEX]);
         robust_ftruncate(conchFile->h, writeSize);
         rc = unixWrite((sqlite3_file *)conchFile, writeBuffer, writeSize, 0);
-        fsync(conchFile->h);
+        full_fsync(conchFile->h,0,0);
         /* If we created a new conch file (not just updated the contents of a 
          ** valid conch file), try to match the permissions of the database 
          */
@@ -34549,7 +34845,7 @@ SQLITE_API int SQLITE_STDCALL sqlite3_os_init(void){
 
   /* Double-check that the aSyscall[] array has been constructed
   ** correctly.  See ticket [bb3a86e890c8e96ab] */
-  assert( ArraySize(aSyscall)==27 );
+  assert( ArraySize(aSyscall)==28 );
 
   /* Register all VFSes defined in the aVfs[] array */
   for(i=0; i<(sizeof(aVfs)/sizeof(sqlite3_vfs)); i++){
@@ -34632,8 +34928,8 @@ SQLITE_API int SQLITE_STDCALL sqlite3_os_end(void){
 */
 #ifdef SQLITE_PERFORMANCE_TRACE
 
-/* 
-** hwtime.h contains inline assembler code for implementing 
+/*
+** hwtime.h contains inline assembler code for implementing
 ** high-performance timing routines.
 */
 /************** Include hwtime.h in the middle of os_common.h ****************/
@@ -34743,14 +35039,14 @@ static sqlite_uint64 g_elapsed;
 ** of code will give us the ability to simulate a disk I/O error.  This
 ** is used for testing the I/O recovery logic.
 */
-#ifdef SQLITE_TEST
-SQLITE_API int sqlite3_io_error_hit = 0;            /* Total number of I/O Errors */
-SQLITE_API int sqlite3_io_error_hardhit = 0;        /* Number of non-benign errors */
-SQLITE_API int sqlite3_io_error_pending = 0;        /* Count down to first I/O error */
-SQLITE_API int sqlite3_io_error_persist = 0;        /* True if I/O errors persist */
-SQLITE_API int sqlite3_io_error_benign = 0;         /* True if errors are benign */
-SQLITE_API int sqlite3_diskfull_pending = 0;
-SQLITE_API int sqlite3_diskfull = 0;
+#if defined(SQLITE_TEST)
+SQLITE_API extern int sqlite3_io_error_hit;
+SQLITE_API extern int sqlite3_io_error_hardhit;
+SQLITE_API extern int sqlite3_io_error_pending;
+SQLITE_API extern int sqlite3_io_error_persist;
+SQLITE_API extern int sqlite3_io_error_benign;
+SQLITE_API extern int sqlite3_diskfull_pending;
+SQLITE_API extern int sqlite3_diskfull;
 #define SimulateIOErrorBenign(X) sqlite3_io_error_benign=(X)
 #define SimulateIOError(CODE)  \
   if( (sqlite3_io_error_persist && sqlite3_io_error_hit) \
@@ -34776,17 +35072,17 @@ static void local_ioerr(){
 #define SimulateIOErrorBenign(X)
 #define SimulateIOError(A)
 #define SimulateDiskfullError(A)
-#endif
+#endif /* defined(SQLITE_TEST) */
 
 /*
 ** When testing, keep a count of the number of open files.
 */
-#ifdef SQLITE_TEST
-SQLITE_API int sqlite3_open_file_count = 0;
+#if defined(SQLITE_TEST)
+SQLITE_API extern int sqlite3_open_file_count;
 #define OpenCounter(X)  sqlite3_open_file_count+=(X)
 #else
 #define OpenCounter(X)
-#endif
+#endif /* defined(SQLITE_TEST) */
 
 #endif /* !defined(_OS_COMMON_H_) */
 
@@ -34849,6 +35145,10 @@ SQLITE_API int sqlite3_open_file_count = 0;
 #  define NTDDI_WINBLUE                     0x06030000
 #endif
 
+#ifndef NTDDI_WINTHRESHOLD
+#  define NTDDI_WINTHRESHOLD                0x06040000
+#endif
+
 /*
 ** Check to see if the GetVersionEx[AW] functions are deprecated on the
 ** target system.  GetVersionEx was first deprecated in Win8.1.
@@ -34861,6 +35161,19 @@ SQLITE_API int sqlite3_open_file_count = 0;
 #  endif
 #endif
 
+/*
+** Check to see if the CreateFileMappingA function is supported on the
+** target system.  It is unavailable when using "mincore.lib" on Win10.
+** When compiling for Windows 10, always assume "mincore.lib" is in use.
+*/
+#ifndef SQLITE_WIN32_CREATEFILEMAPPINGA
+#  if defined(NTDDI_VERSION) && NTDDI_VERSION >= NTDDI_WINTHRESHOLD
+#    define SQLITE_WIN32_CREATEFILEMAPPINGA   0
+#  else
+#    define SQLITE_WIN32_CREATEFILEMAPPINGA   1
+#  endif
+#endif
+
 /*
 ** This constant should already be defined (in the "WinDef.h" SDK file).
 */
@@ -35267,8 +35580,9 @@ static struct win_syscall {
 #define osCreateFileW ((HANDLE(WINAPI*)(LPCWSTR,DWORD,DWORD, \
         LPSECURITY_ATTRIBUTES,DWORD,DWORD,HANDLE))aSyscall[5].pCurrent)
 
-#if (!SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_ANSI) && \
-        (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0))
+#if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_ANSI) && \
+        (!defined(SQLITE_OMIT_WAL) || SQLITE_MAX_MMAP_SIZE>0) && \
+        SQLITE_WIN32_CREATEFILEMAPPINGA
   { "CreateFileMappingA",      (SYSCALL)CreateFileMappingA,      0 },
 #else
   { "CreateFileMappingA",      (SYSCALL)0,                       0 },
@@ -35498,8 +35812,7 @@ static struct win_syscall {
 
 #define osGetTickCount ((DWORD(WINAPI*)(VOID))aSyscall[33].pCurrent)
 
-#if defined(SQLITE_WIN32_HAS_ANSI) && defined(SQLITE_WIN32_GETVERSIONEX) && \
-        SQLITE_WIN32_GETVERSIONEX
+#if defined(SQLITE_WIN32_HAS_ANSI) && SQLITE_WIN32_GETVERSIONEX
   { "GetVersionExA",           (SYSCALL)GetVersionExA,           0 },
 #else
   { "GetVersionExA",           (SYSCALL)0,                       0 },
@@ -35509,7 +35822,7 @@ static struct win_syscall {
         LPOSVERSIONINFOA))aSyscall[34].pCurrent)
 
 #if !SQLITE_OS_WINRT && defined(SQLITE_WIN32_HAS_WIDE) && \
-        defined(SQLITE_WIN32_GETVERSIONEX) && SQLITE_WIN32_GETVERSIONEX
+        SQLITE_WIN32_GETVERSIONEX
   { "GetVersionExW",           (SYSCALL)GetVersionExW,           0 },
 #else
   { "GetVersionExW",           (SYSCALL)0,                       0 },
@@ -36120,7 +36433,7 @@ SQLITE_PRIVATE DWORD sqlite3Win32Wait(HANDLE hObject){
 ** the LockFileEx() API.
 */
 
-#if !defined(SQLITE_WIN32_GETVERSIONEX) || !SQLITE_WIN32_GETVERSIONEX
+#if !SQLITE_WIN32_GETVERSIONEX
 # define osIsNT()  (1)
 #elif SQLITE_OS_WINCE || SQLITE_OS_WINRT || !defined(SQLITE_WIN32_HAS_ANSI)
 # define osIsNT()  (1)
@@ -36141,7 +36454,7 @@ SQLITE_API int SQLITE_STDCALL sqlite3_win32_is_nt(void){
   **       kernel.
   */
   return 1;
-#elif defined(SQLITE_WIN32_GETVERSIONEX) && SQLITE_WIN32_GETVERSIONEX
+#elif SQLITE_WIN32_GETVERSIONEX
   if( osInterlockedCompareExchange(&sqlite3_os_type, 0, 0)==0 ){
 #if defined(SQLITE_WIN32_HAS_ANSI)
     OSVERSIONINFOA sInfo;
@@ -38725,7 +39038,7 @@ static int winShmMap(
       hMap = osCreateFileMappingW(pShmNode->hFile.h,
           NULL, PAGE_READWRITE, 0, nByte, NULL
       );
-#elif defined(SQLITE_WIN32_HAS_ANSI)
+#elif defined(SQLITE_WIN32_HAS_ANSI) && SQLITE_WIN32_CREATEFILEMAPPINGA
       hMap = osCreateFileMappingA(pShmNode->hFile.h,
           NULL, PAGE_READWRITE, 0, nByte, NULL
       );
@@ -38881,7 +39194,7 @@ static int winMapfile(winFile *pFd, sqlite3_int64 nByte){
     pFd->hMap = osCreateFileMappingW(pFd->h, NULL, protect,
                                 (DWORD)((nMap>>32) & 0xffffffff),
                                 (DWORD)(nMap & 0xffffffff), NULL);
-#elif defined(SQLITE_WIN32_HAS_ANSI)
+#elif defined(SQLITE_WIN32_HAS_ANSI) && SQLITE_WIN32_CREATEFILEMAPPINGA
     pFd->hMap = osCreateFileMappingA(pFd->h, NULL, protect,
                                 (DWORD)((nMap>>32) & 0xffffffff),
                                 (DWORD)(nMap & 0xffffffff), NULL);
@@ -42945,7 +43258,7 @@ static struct RowSetEntry *rowSetEntryAlloc(RowSet *p){
   assert( p!=0 );
   if( p->nFresh==0 ){
     struct RowSetChunk *pNew;
-    pNew = sqlite3DbMallocRaw(p->db, sizeof(*pNew));
+    pNew = sqlite3DbMallocRawNN(p->db, sizeof(*pNew));
     if( pNew==0 ){
       return 0;
     }
@@ -43853,6 +44166,20 @@ int sqlite3PagerTrace=1;  /* True to enable tracing */
 */
 #define MAX_SECTOR_SIZE 0x10000
 
+/*
+** If the option SQLITE_EXTRA_DURABLE option is set at compile-time, then
+** SQLite will do extra fsync() operations when synchronous==FULL to help
+** ensure that transactions are durable across a power failure.  Most
+** applications are happy as long as transactions are consistent across
+** a power failure, and are perfectly willing to lose the last transaction
+** in exchange for the extra performance of avoiding directory syncs.
+** And so the default SQLITE_EXTRA_DURABLE setting is off.
+*/
+#ifndef SQLITE_EXTRA_DURABLE
+# define SQLITE_EXTRA_DURABLE 0
+#endif
+
+
 /*
 ** An instance of the following structure is allocated for each active
 ** savepoint and statement transaction in the system. All such structures
@@ -44048,6 +44375,7 @@ struct Pager {
   u8 useJournal;              /* Use a rollback journal on this file */
   u8 noSync;                  /* Do not sync the journal if true */
   u8 fullSync;                /* Do extra syncs of the journal for robustness */
+  u8 extraSync;               /* sync directory after journal delete */
   u8 ckptSyncFlags;           /* SYNC_NORMAL or SYNC_FULL for checkpoint */
   u8 walSyncFlags;            /* SYNC_NORMAL or SYNC_FULL for wal writes */
   u8 syncFlags;               /* SYNC_NORMAL or SYNC_FULL otherwise */
@@ -45408,7 +45736,7 @@ static int pager_end_transaction(Pager *pPager, int hasMaster, int bCommit){
       );
       sqlite3OsClose(pPager->jfd);
       if( bDelete ){
-        rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, 0);
+        rc = sqlite3OsDelete(pPager->pVfs, pPager->zJournal, pPager->extraSync);
       }
     }
   }
@@ -46914,9 +47242,15 @@ SQLITE_PRIVATE void sqlite3PagerSetFlags(
   unsigned pgFlags      /* Various flags */
 ){
   unsigned level = pgFlags & PAGER_SYNCHRONOUS_MASK;
-  assert( level>=1 && level<=3 );
-  pPager->noSync =  (level==1 || pPager->tempFile) ?1:0;
-  pPager->fullSync = (level==3 && !pPager->tempFile) ?1:0;
+  if( pPager->tempFile ){
+    pPager->noSync = 1;
+    pPager->fullSync = 0;
+    pPager->extraSync = 0;
+  }else{
+    pPager->noSync =  level==PAGER_SYNCHRONOUS_OFF ?1:0;
+    pPager->fullSync = level>=PAGER_SYNCHRONOUS_FULL ?1:0;
+    pPager->extraSync = level==PAGER_SYNCHRONOUS_EXTRA ?1:0;
+  }
   if( pPager->noSync ){
     pPager->syncFlags = 0;
     pPager->ckptSyncFlags = 0;
@@ -48221,11 +48555,17 @@ act_like_temp_file:
   pPager->noSync = pPager->tempFile;
   if( pPager->noSync ){
     assert( pPager->fullSync==0 );
+    assert( pPager->extraSync==0 );
     assert( pPager->syncFlags==0 );
     assert( pPager->walSyncFlags==0 );
     assert( pPager->ckptSyncFlags==0 );
   }else{
     pPager->fullSync = 1;
+#if SQLITE_EXTRA_DURABLE
+    pPager->extraSync = 1;
+#else
+    pPager->extraSync = 0;
+#endif
     pPager->syncFlags = SQLITE_SYNC_NORMAL;
     pPager->walSyncFlags = SQLITE_SYNC_NORMAL | WAL_SYNC_TRANSACTIONS;
     pPager->ckptSyncFlags = SQLITE_SYNC_NORMAL;
@@ -51234,6 +51574,7 @@ struct Wal {
   u8 padToSectorBoundary;    /* Pad transactions out to the next sector */
   WalIndexHdr hdr;           /* Wal-index header for current transaction */
   u32 minFrame;              /* Ignore wal frames before this one */
+  u32 iReCksum;              /* On commit, recalculate checksums from here */
   const char *zWalName;      /* Name of WAL file */
   u32 nCkpt;                 /* Checkpoint sequence counter in the wal-header */
 #ifdef SQLITE_DEBUG
@@ -51487,14 +51828,18 @@ static void walEncodeFrame(
   assert( WAL_FRAME_HDRSIZE==24 );
   sqlite3Put4byte(&aFrame[0], iPage);
   sqlite3Put4byte(&aFrame[4], nTruncate);
-  memcpy(&aFrame[8], pWal->hdr.aSalt, 8);
+  if( pWal->iReCksum==0 ){
+    memcpy(&aFrame[8], pWal->hdr.aSalt, 8);
 
-  nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);
-  walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum);
-  walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
+    nativeCksum = (pWal->hdr.bigEndCksum==SQLITE_BIGENDIAN);
+    walChecksumBytes(nativeCksum, aFrame, 8, aCksum, aCksum);
+    walChecksumBytes(nativeCksum, aData, pWal->szPage, aCksum, aCksum);
 
-  sqlite3Put4byte(&aFrame[16], aCksum[0]);
-  sqlite3Put4byte(&aFrame[20], aCksum[1]);
+    sqlite3Put4byte(&aFrame[16], aCksum[0]);
+    sqlite3Put4byte(&aFrame[20], aCksum[1]);
+  }else{
+    memset(&aFrame[8], 0, 16);
+  }
 }
 
 /*
@@ -53421,6 +53766,7 @@ SQLITE_PRIVATE int sqlite3WalBeginWriteTransaction(Wal *pWal){
   /* Cannot start a write transaction without first holding a read
   ** transaction. */
   assert( pWal->readLock>=0 );
+  assert( pWal->writeLock==0 && pWal->iReCksum==0 );
 
   if( pWal->readOnly ){
     return SQLITE_READONLY;
@@ -53456,6 +53802,7 @@ SQLITE_PRIVATE int sqlite3WalEndWriteTransaction(Wal *pWal){
   if( pWal->writeLock ){
     walUnlockExclusive(pWal, WAL_WRITE_LOCK, 1);
     pWal->writeLock = 0;
+    pWal->iReCksum = 0;
     pWal->truncateOnCommit = 0;
   }
   return SQLITE_OK;
@@ -53674,6 +54021,59 @@ static int walWriteOneFrame(
   return rc;
 }
 
+/*
+** This function is called as part of committing a transaction within which
+** one or more frames have been overwritten. It updates the checksums for
+** all frames written to the wal file by the current transaction starting
+** with the earliest to have been overwritten.
+**
+** SQLITE_OK is returned if successful, or an SQLite error code otherwise.
+*/
+static int walRewriteChecksums(Wal *pWal, u32 iLast){
+  const int szPage = pWal->szPage;/* Database page size */
+  int rc = SQLITE_OK;             /* Return code */
+  u8 *aBuf;                       /* Buffer to load data from wal file into */
+  u8 aFrame[WAL_FRAME_HDRSIZE];   /* Buffer to assemble frame-headers in */
+  u32 iRead;                      /* Next frame to read from wal file */
+  i64 iCksumOff;
+
+  aBuf = sqlite3_malloc(szPage + WAL_FRAME_HDRSIZE);
+  if( aBuf==0 ) return SQLITE_NOMEM;
+
+  /* Find the checksum values to use as input for the recalculating the
+  ** first checksum. If the first frame is frame 1 (implying that the current
+  ** transaction restarted the wal file), these values must be read from the
+  ** wal-file header. Otherwise, read them from the frame header of the
+  ** previous frame.  */
+  assert( pWal->iReCksum>0 );
+  if( pWal->iReCksum==1 ){
+    iCksumOff = 24;
+  }else{
+    iCksumOff = walFrameOffset(pWal->iReCksum-1, szPage) + 16;
+  }
+  rc = sqlite3OsRead(pWal->pWalFd, aBuf, sizeof(u32)*2, iCksumOff);
+  pWal->hdr.aFrameCksum[0] = sqlite3Get4byte(aBuf);
+  pWal->hdr.aFrameCksum[1] = sqlite3Get4byte(&aBuf[sizeof(u32)]);
+
+  iRead = pWal->iReCksum;
+  pWal->iReCksum = 0;
+  for(; rc==SQLITE_OK && iRead<=iLast; iRead++){
+    i64 iOff = walFrameOffset(iRead, szPage);
+    rc = sqlite3OsRead(pWal->pWalFd, aBuf, szPage+WAL_FRAME_HDRSIZE, iOff);
+    if( rc==SQLITE_OK ){
+      u32 iPgno, nDbSize;
+      iPgno = sqlite3Get4byte(aBuf);
+      nDbSize = sqlite3Get4byte(&aBuf[4]);
+
+      walEncodeFrame(pWal, iPgno, nDbSize, &aBuf[WAL_FRAME_HDRSIZE], aFrame);
+      rc = sqlite3OsWrite(pWal->pWalFd, aFrame, sizeof(aFrame), iOff);
+    }
+  }
+
+  sqlite3_free(aBuf);
+  return rc;
+}
+
 /* 
 ** Write a set of frames to the log. The caller must hold the write-lock
 ** on the log file (obtained using sqlite3WalBeginWriteTransaction()).
@@ -53694,6 +54094,8 @@ SQLITE_PRIVATE int sqlite3WalFrames(
   int szFrame;                    /* The size of a single frame */
   i64 iOffset;                    /* Next byte to write in WAL file */
   WalWriter w;                    /* The writer */
+  u32 iFirst = 0;                 /* First frame that may be overwritten */
+  WalIndexHdr *pLive;             /* Pointer to shared header */
 
   assert( pList );
   assert( pWal->writeLock );
@@ -53709,6 +54111,11 @@ SQLITE_PRIVATE int sqlite3WalFrames(
   }
 #endif
 
+  pLive = (WalIndexHdr*)walIndexHdr(pWal);
+  if( memcmp(&pWal->hdr, (void *)pLive, sizeof(WalIndexHdr))!=0 ){
+    iFirst = pLive->mxFrame+1;
+  }
+
   /* See if it is possible to write these frames into the start of the
   ** log file, instead of appending to it at pWal->hdr.mxFrame.
   */
@@ -53773,6 +54180,33 @@ SQLITE_PRIVATE int sqlite3WalFrames(
   /* Write all frames into the log file exactly once */
   for(p=pList; p; p=p->pDirty){
     int nDbSize;   /* 0 normally.  Positive == commit flag */
+
+    /* Check if this page has already been written into the wal file by
+    ** the current transaction. If so, overwrite the existing frame and
+    ** set Wal.writeLock to WAL_WRITELOCK_RECKSUM - indicating that 
+    ** checksums must be recomputed when the transaction is committed.  */
+    if( iFirst && (p->pDirty || isCommit==0) ){
+      u32 iWrite = 0;
+      VVA_ONLY(rc =) sqlite3WalFindFrame(pWal, p->pgno, &iWrite);
+      assert( rc==SQLITE_OK || iWrite==0 );
+      if( iWrite>=iFirst ){
+        i64 iOff = walFrameOffset(iWrite, szPage) + WAL_FRAME_HDRSIZE;
+        void *pData;
+        if( pWal->iReCksum==0 || iWrite<pWal->iReCksum ){
+          pWal->iReCksum = iWrite;
+        }
+#if defined(SQLITE_HAS_CODEC)
+        if( (pData = sqlite3PagerCodec(p))==0 ) return SQLITE_NOMEM;
+#else
+        pData = p->pData;
+#endif
+        rc = sqlite3OsWrite(pWal->pWalFd, pData, szPage, iOff);
+        if( rc ) return rc;
+        p->flags &= ~PGHDR_WAL_APPEND;
+        continue;
+      }
+    }
+
     iFrame++;
     assert( iOffset==walFrameOffset(iFrame, szPage) );
     nDbSize = (isCommit && p->pDirty==0) ? nTruncate : 0;
@@ -53780,6 +54214,13 @@ SQLITE_PRIVATE int sqlite3WalFrames(
     if( rc ) return rc;
     pLast = p;
     iOffset += szFrame;
+    p->flags |= PGHDR_WAL_APPEND;
+  }
+
+  /* Recalculate checksums within the wal file if required. */
+  if( isCommit && pWal->iReCksum ){
+    rc = walRewriteChecksums(pWal, iFrame);
+    if( rc ) return rc;
   }
 
   /* If this is the end of a transaction, then we might need to pad
@@ -53831,6 +54272,7 @@ SQLITE_PRIVATE int sqlite3WalFrames(
   */
   iFrame = pWal->hdr.mxFrame;
   for(p=pList; p && rc==SQLITE_OK; p=p->pDirty){
+    if( (p->flags & PGHDR_WAL_APPEND)==0 ) continue;
     iFrame++;
     rc = walIndexAppend(pWal, iFrame, p->pgno);
   }
@@ -53943,6 +54385,7 @@ SQLITE_PRIVATE int sqlite3WalCheckpoint(
 
   /* Copy data from the log to the database file. */
   if( rc==SQLITE_OK ){
+
     if( pWal->hdr.mxFrame && walPagesize(pWal)!=nBuf ){
       rc = SQLITE_CORRUPT_BKPT;
     }else{
@@ -54406,7 +54849,6 @@ struct MemPage {
   u8 nOverflow;        /* Number of overflow cell bodies in aCell[] */
   u8 intKey;           /* True if table b-trees.  False for index b-trees */
   u8 intKeyLeaf;       /* True if the leaf of an intKey table */
-  u8 noPayload;        /* True if internal intKey page (thus w/o data) */
   u8 leaf;             /* True if a leaf page */
   u8 hdrOffset;        /* 100 for page 1.  0 otherwise */
   u8 childPtrSize;     /* 0 if leaf==1.  4 if leaf==0 */
@@ -54994,21 +55436,6 @@ SQLITE_PRIVATE int sqlite3BtreeHoldsMutex(Btree *p){
 #endif
 
 
-#ifndef SQLITE_OMIT_INCRBLOB
-/*
-** Enter and leave a mutex on a Btree given a cursor owned by that
-** Btree.  These entry points are used by incremental I/O and can be
-** omitted if that module is not used.
-*/
-SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
-  sqlite3BtreeEnter(pCur->pBtree);
-}
-SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
-  sqlite3BtreeLeave(pCur->pBtree);
-}
-#endif /* SQLITE_OMIT_INCRBLOB */
-
-
 /*
 ** Enter the mutex on every Btree associated with a database
 ** connection.  This is needed (for example) prior to parsing
@@ -55042,14 +55469,6 @@ SQLITE_PRIVATE void sqlite3BtreeLeaveAll(sqlite3 *db){
   }
 }
 
-/*
-** Return true if a particular Btree requires a lock.  Return FALSE if
-** no lock is ever required since it is not sharable.
-*/
-SQLITE_PRIVATE int sqlite3BtreeSharable(Btree *p){
-  return p->sharable;
-}
-
 #ifndef NDEBUG
 /*
 ** Return true if the current thread holds the database connection
@@ -55123,6 +55542,25 @@ SQLITE_PRIVATE void sqlite3BtreeEnterAll(sqlite3 *db){
   }
 }
 #endif /* if SQLITE_THREADSAFE */
+
+#ifndef SQLITE_OMIT_INCRBLOB
+/*
+** Enter a mutex on a Btree given a cursor owned by that Btree. 
+**
+** These entry points are used by incremental I/O only. Enter() is required 
+** any time OMIT_SHARED_CACHE is not defined, regardless of whether or not 
+** the build is threadsafe. Leave() is only required by threadsafe builds.
+*/
+SQLITE_PRIVATE void sqlite3BtreeEnterCursor(BtCursor *pCur){
+  sqlite3BtreeEnter(pCur->pBtree);
+}
+# if SQLITE_THREADSAFE
+SQLITE_PRIVATE void sqlite3BtreeLeaveCursor(BtCursor *pCur){
+  sqlite3BtreeLeave(pCur->pBtree);
+}
+# endif
+#endif /* ifndef SQLITE_OMIT_INCRBLOB */
+
 #endif /* ifndef SQLITE_OMIT_SHARED_CACHE */
 
 /************** End of btmutex.c *********************************************/
@@ -55579,6 +56017,10 @@ static void releasePage(MemPage *pPage);  /* Forward reference */
 static int cursorHoldsMutex(BtCursor *p){
   return sqlite3_mutex_held(p->pBt->mutex);
 }
+static int cursorOwnsBtShared(BtCursor *p){
+  assert( cursorHoldsMutex(p) );
+  return (p->pBtree->db==p->pBt->db);
+}
 #endif
 
 /*
@@ -55915,7 +56357,7 @@ static int btreeMoveto(
 static int btreeRestoreCursorPosition(BtCursor *pCur){
   int rc;
   int skipNext;
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( pCur->eState>=CURSOR_REQUIRESEEK );
   if( pCur->eState==CURSOR_FAULT ){
     return pCur->skipNext;
@@ -56204,7 +56646,6 @@ static void btreeParseCellPtrNoPayload(
 ){
   assert( sqlite3_mutex_held(pPage->pBt->mutex) );
   assert( pPage->leaf==0 );
-  assert( pPage->noPayload );
   assert( pPage->childPtrSize==4 );
 #ifndef SQLITE_DEBUG
   UNUSED_PARAMETER(pPage);
@@ -56226,8 +56667,6 @@ static void btreeParseCellPtr(
 
   assert( sqlite3_mutex_held(pPage->pBt->mutex) );
   assert( pPage->leaf==0 || pPage->leaf==1 );
-  assert( pPage->intKeyLeaf || pPage->noPayload );
-  assert( pPage->noPayload==0 );
   assert( pPage->intKeyLeaf );
   assert( pPage->childPtrSize==0 );
   pIter = pCell;
@@ -56296,7 +56735,6 @@ static void btreeParseCellPtrIndex(
   assert( sqlite3_mutex_held(pPage->pBt->mutex) );
   assert( pPage->leaf==0 || pPage->leaf==1 );
   assert( pPage->intKeyLeaf==0 );
-  assert( pPage->noPayload==0 );
   pIter = pCell + pPage->childPtrSize;
   nPayload = *pIter;
   if( nPayload>=0x80 ){
@@ -56357,7 +56795,6 @@ static u16 cellSizePtr(MemPage *pPage, u8 *pCell){
   pPage->xParseCell(pPage, pCell, &debuginfo);
 #endif
 
-  assert( pPage->noPayload==0 );
   nSize = *pIter;
   if( nSize>=0x80 ){
     pEnd = &pIter[8];
@@ -56815,11 +57252,9 @@ static int decodeFlags(MemPage *pPage, int flagByte){
     pPage->intKey = 1;
     if( pPage->leaf ){
       pPage->intKeyLeaf = 1;
-      pPage->noPayload = 0;
       pPage->xParseCell = btreeParseCellPtr;
     }else{
       pPage->intKeyLeaf = 0;
-      pPage->noPayload = 1;
       pPage->xCellSize = cellSizePtrNoPayload;
       pPage->xParseCell = btreeParseCellPtrNoPayload;
     }
@@ -56834,7 +57269,6 @@ static int decodeFlags(MemPage *pPage, int flagByte){
     assert( (PTF_ZERODATA|PTF_LEAF)==10 );
     pPage->intKey = 0;
     pPage->intKeyLeaf = 0;
-    pPage->noPayload = 0;
     pPage->xParseCell = btreeParseCellPtrIndex;
     pPage->maxLocal = pBt->maxLocal;
     pPage->minLocal = pBt->minLocal;
@@ -57471,7 +57905,6 @@ SQLITE_PRIVATE int sqlite3BtreeOpen(
         pBt->mutex = sqlite3MutexAlloc(SQLITE_MUTEX_FAST);
         if( pBt->mutex==0 ){
           rc = SQLITE_NOMEM;
-          db->mallocFailed = 0;
           goto btree_open_out;
         }
       }
@@ -58255,7 +58688,6 @@ SQLITE_PRIVATE int sqlite3BtreeNewDb(Btree *p){
 ** proceed.
 */
 SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree *p, int wrflag){
-  sqlite3 *pBlock = 0;
   BtShared *pBt = p->pBt;
   int rc = SQLITE_OK;
 
@@ -58278,27 +58710,30 @@ SQLITE_PRIVATE int sqlite3BtreeBeginTrans(Btree *p, int wrflag){
   }
 
 #ifndef SQLITE_OMIT_SHARED_CACHE
-  /* If another database handle has already opened a write transaction 
-  ** on this shared-btree structure and a second write transaction is
-  ** requested, return SQLITE_LOCKED.
-  */
-  if( (wrflag && pBt->inTransaction==TRANS_WRITE)
-   || (pBt->btsFlags & BTS_PENDING)!=0
-  ){
-    pBlock = pBt->pWriter->db;
-  }else if( wrflag>1 ){
-    BtLock *pIter;
-    for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
-      if( pIter->pBtree!=p ){
-        pBlock = pIter->pBtree->db;
-        break;
+  {
+    sqlite3 *pBlock = 0;
+    /* If another database handle has already opened a write transaction 
+    ** on this shared-btree structure and a second write transaction is
+    ** requested, return SQLITE_LOCKED.
+    */
+    if( (wrflag && pBt->inTransaction==TRANS_WRITE)
+     || (pBt->btsFlags & BTS_PENDING)!=0
+    ){
+      pBlock = pBt->pWriter->db;
+    }else if( wrflag>1 ){
+      BtLock *pIter;
+      for(pIter=pBt->pLock; pIter; pIter=pIter->pNext){
+        if( pIter->pBtree!=p ){
+          pBlock = pIter->pBtree->db;
+          break;
+        }
       }
     }
-  }
-  if( pBlock ){
-    sqlite3ConnectionBlocked(p->db, pBlock);
-    rc = SQLITE_LOCKED_SHAREDCACHE;
-    goto trans_begun;
+    if( pBlock ){
+      sqlite3ConnectionBlocked(p->db, pBlock);
+      rc = SQLITE_LOCKED_SHAREDCACHE;
+      goto trans_begun;
+    }
   }
 #endif
 
@@ -59180,13 +59615,13 @@ SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *p, int op, int iSavepoint){
 ** on the database already. If a write-cursor is requested, then
 ** the caller is assumed to have an open write transaction.
 **
-** If wrFlag==0, then the cursor can only be used for reading.
-** If wrFlag==1, then the cursor can be used for reading or for
-** writing if other conditions for writing are also met.  These
-** are the conditions that must be met in order for writing to
-** be allowed:
+** If the BTREE_WRCSR bit of wrFlag is clear, then the cursor can only
+** be used for reading.  If the BTREE_WRCSR bit is set, then the cursor
+** can be used for reading or for writing if other conditions for writing
+** are also met.  These are the conditions that must be met in order
+** for writing to be allowed:
 **
-** 1:  The cursor must have been opened with wrFlag==1
+** 1:  The cursor must have been opened with wrFlag containing BTREE_WRCSR
 **
 ** 2:  Other database connections that share the same pager cache
 **     but which are not in the READ_UNCOMMITTED state may not have
@@ -59198,6 +59633,16 @@ SQLITE_PRIVATE int sqlite3BtreeSavepoint(Btree *p, int op, int iSavepoint){
 **
 ** 4:  There must be an active transaction.
 **
+** The BTREE_FORDELETE bit of wrFlag may optionally be set if BTREE_WRCSR
+** is set.  If FORDELETE is set, that is a hint to the implementation that
+** this cursor will only be used to seek to and delete entries of an index
+** as part of a larger DELETE statement.  The FORDELETE hint is not used by
+** this implementation.  But in a hypothetical alternative storage engine 
+** in which index entries are automatically deleted when corresponding table
+** rows are deleted, the FORDELETE flag is a hint that all SEEK and DELETE
+** operations on this cursor can be no-ops and all READ operations can 
+** return a null row (2-bytes: 0x01 0x00).
+**
 ** No checking is done to make sure that page iTable really is the
 ** root page of a b-tree.  If it is not, then the cursor acquired
 ** will not work correctly.
@@ -59415,7 +59860,7 @@ SQLITE_PRIVATE int sqlite3BtreeKeySize(BtCursor *pCur, i64 *pSize){
 ** to return an integer result code for historical reasons.
 */
 SQLITE_PRIVATE int sqlite3BtreeDataSize(BtCursor *pCur, u32 *pSize){
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( pCur->eState==CURSOR_VALID );
   assert( pCur->iPage>=0 );
   assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
@@ -59795,7 +60240,7 @@ SQLITE_PRIVATE int sqlite3BtreeData(BtCursor *pCur, u32 offset, u32 amt, void *p
   }
 #endif
 
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   rc = restoreCursorPosition(pCur);
   if( rc==SQLITE_OK ){
     assert( pCur->eState==CURSOR_VALID );
@@ -59833,7 +60278,7 @@ static const void *fetchPayload(
   assert( pCur!=0 && pCur->iPage>=0 && pCur->apPage[pCur->iPage]);
   assert( pCur->eState==CURSOR_VALID );
   assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
   assert( pCur->info.nSize>0 );
   assert( pCur->info.pPayload>pCur->apPage[pCur->iPage]->aData || CORRUPT_DB );
@@ -59879,7 +60324,7 @@ SQLITE_PRIVATE const void *sqlite3BtreeDataFetch(BtCursor *pCur, u32 *pAmt){
 static int moveToChild(BtCursor *pCur, u32 newPgno){
   BtShared *pBt = pCur->pBt;
 
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( pCur->eState==CURSOR_VALID );
   assert( pCur->iPage<BTCURSOR_MAX_DEPTH );
   assert( pCur->iPage>=0 );
@@ -59925,7 +60370,7 @@ static void assertParentIndex(MemPage *pParent, int iIdx, Pgno iChild){
 ** the largest cell index.
 */
 static void moveToParent(BtCursor *pCur){
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( pCur->eState==CURSOR_VALID );
   assert( pCur->iPage>0 );
   assert( pCur->apPage[pCur->iPage] );
@@ -59965,7 +60410,7 @@ static int moveToRoot(BtCursor *pCur){
   MemPage *pRoot;
   int rc = SQLITE_OK;
 
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( CURSOR_INVALID < CURSOR_REQUIRESEEK );
   assert( CURSOR_VALID   < CURSOR_REQUIRESEEK );
   assert( CURSOR_FAULT   > CURSOR_REQUIRESEEK );
@@ -60044,7 +60489,7 @@ static int moveToLeftmost(BtCursor *pCur){
   int rc = SQLITE_OK;
   MemPage *pPage;
 
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( pCur->eState==CURSOR_VALID );
   while( rc==SQLITE_OK && !(pPage = pCur->apPage[pCur->iPage])->leaf ){
     assert( pCur->aiIdx[pCur->iPage]<pPage->nCell );
@@ -60069,7 +60514,7 @@ static int moveToRightmost(BtCursor *pCur){
   int rc = SQLITE_OK;
   MemPage *pPage = 0;
 
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( pCur->eState==CURSOR_VALID );
   while( !(pPage = pCur->apPage[pCur->iPage])->leaf ){
     pgno = get4byte(&pPage->aData[pPage->hdrOffset+8]);
@@ -60090,7 +60535,7 @@ static int moveToRightmost(BtCursor *pCur){
 SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
   int rc;
 
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
   rc = moveToRoot(pCur);
   if( rc==SQLITE_OK ){
@@ -60113,7 +60558,7 @@ SQLITE_PRIVATE int sqlite3BtreeFirst(BtCursor *pCur, int *pRes){
 SQLITE_PRIVATE int sqlite3BtreeLast(BtCursor *pCur, int *pRes){
   int rc;
  
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
 
   /* If the cursor already points to the last entry, this is a no-op. */
@@ -60191,7 +60636,7 @@ SQLITE_PRIVATE int sqlite3BtreeMovetoUnpacked(
   int rc;
   RecordCompare xRecordCompare;
 
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( sqlite3_mutex_held(pCur->pBtree->db->mutex) );
   assert( pRes );
   assert( (pIdxKey==0)==(pCur->pKeyInfo==0) );
@@ -60439,7 +60884,7 @@ static SQLITE_NOINLINE int btreeNext(BtCursor *pCur, int *pRes){
   int idx;
   MemPage *pPage;
 
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
   assert( *pRes==0 );
   if( pCur->eState!=CURSOR_VALID ){
@@ -60503,7 +60948,7 @@ static SQLITE_NOINLINE int btreeNext(BtCursor *pCur, int *pRes){
 }
 SQLITE_PRIVATE int sqlite3BtreeNext(BtCursor *pCur, int *pRes){
   MemPage *pPage;
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( pRes!=0 );
   assert( *pRes==0 || *pRes==1 );
   assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
@@ -60548,7 +60993,7 @@ static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur, int *pRes){
   int rc;
   MemPage *pPage;
 
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( pRes!=0 );
   assert( *pRes==0 );
   assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
@@ -60604,7 +61049,7 @@ static SQLITE_NOINLINE int btreePrevious(BtCursor *pCur, int *pRes){
   return rc;
 }
 SQLITE_PRIVATE int sqlite3BtreePrevious(BtCursor *pCur, int *pRes){
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( pRes!=0 );
   assert( *pRes==0 || *pRes==1 );
   assert( pCur->skipNext==0 || pCur->eState!=CURSOR_VALID );
@@ -61270,7 +61715,7 @@ static int fillInCell(
   {
     CellInfo info;
     pPage->xParseCell(pPage, pCell, &info);
-    assert( nHeader=(int)(info.pPayload - pCell) );
+    assert( nHeader==(int)(info.pPayload - pCell) );
     assert( info.nKey==nKey );
     assert( *pnSize == info.nSize );
     assert( spaceLeft == info.nLocal );
@@ -62317,9 +62762,8 @@ static int balance_nonroot(
     ** long be able to find the cells if a pointer to each cell is not saved
     ** first.
     */
-    memset(&b.szCell[b.nCell], 0, sizeof(b.szCell[0])*limit);
+    memset(&b.szCell[b.nCell], 0, sizeof(b.szCell[0])*(limit+pOld->nOverflow));
     if( pOld->nOverflow>0 ){
-      memset(&b.szCell[b.nCell+limit], 0, sizeof(b.szCell[0])*pOld->nOverflow);
       limit = pOld->aiOvfl[0];
       for(j=0; j<limit; j++){
         b.apCell[b.nCell] = aData + (maskPage & get2byteAligned(piCell));
@@ -62930,8 +63374,8 @@ static int balance(BtCursor *pCur){
   u8 aBalanceQuickSpace[13];
   u8 *pFree = 0;
 
-  TESTONLY( int balance_quick_called = 0 );
-  TESTONLY( int balance_deeper_called = 0 );
+  VVA_ONLY( int balance_quick_called = 0 );
+  VVA_ONLY( int balance_deeper_called = 0 );
 
   do {
     int iPage = pCur->iPage;
@@ -62944,7 +63388,8 @@ static int balance(BtCursor *pCur){
         ** and copy the current contents of the root-page to it. The
         ** next iteration of the do-loop will balance the child page.
         */ 
-        assert( (balance_deeper_called++)==0 );
+        assert( balance_deeper_called==0 );
+        VVA_ONLY( balance_deeper_called++ );
         rc = balance_deeper(pPage, &pCur->apPage[1]);
         if( rc==SQLITE_OK ){
           pCur->iPage = 1;
@@ -62983,7 +63428,8 @@ static int balance(BtCursor *pCur){
           ** function. If this were not verified, a subtle bug involving reuse
           ** of the aBalanceQuickSpace[] might sneak in.
           */
-          assert( (balance_quick_called++)==0 );
+          assert( balance_quick_called==0 ); 
+          VVA_ONLY( balance_quick_called++ );
           rc = balance_quick(pParent, pPage, aBalanceQuickSpace);
         }else
 #endif
@@ -63084,7 +63530,7 @@ SQLITE_PRIVATE int sqlite3BtreeInsert(
     return pCur->skipNext;
   }
 
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( (pCur->curFlags & BTCF_WriteFlag)!=0
               && pBt->inTransaction==TRANS_WRITE
               && (pBt->btsFlags & BTS_READ_ONLY)==0 );
@@ -63214,13 +63660,21 @@ end_insert:
 /*
 ** Delete the entry that the cursor is pointing to. 
 **
-** If the second parameter is zero, then the cursor is left pointing at an
-** arbitrary location after the delete. If it is non-zero, then the cursor 
-** is left in a state such that the next call to BtreeNext() or BtreePrev()
-** moves it to the same row as it would if the call to BtreeDelete() had
-** been omitted.
+** If the BTREE_SAVEPOSITION bit of the flags parameter is zero, then
+** the cursor is left pointing at an arbitrary location after the delete.
+** But if that bit is set, then the cursor is left in a state such that
+** the next call to BtreeNext() or BtreePrev() moves it to the same row
+** as it would have been on if the call to BtreeDelete() had been omitted.
+**
+** The BTREE_AUXDELETE bit of flags indicates that is one of several deletes
+** associated with a single table entry and its indexes.  Only one of those
+** deletes is considered the "primary" delete.  The primary delete occurs
+** on a cursor that is not a BTREE_FORDELETE cursor.  All but one delete
+** operation on non-FORDELETE cursors is tagged with the AUXDELETE flag.
+** The BTREE_AUXDELETE bit is a hint that is not used by this implementation,
+** but which might be used by alternative storage engines.
 */
-SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, int bPreserve){
+SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, u8 flags){
   Btree *p = pCur->pBtree;
   BtShared *pBt = p->pBt;              
   int rc;                              /* Return code */
@@ -63230,8 +63684,9 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, int bPreserve){
   int iCellDepth;                      /* Depth of node containing pCell */ 
   u16 szCell;                          /* Size of the cell being deleted */
   int bSkipnext = 0;                   /* Leaf cursor in SKIPNEXT state */
+  u8 bPreserve = flags & BTREE_SAVEPOSITION;  /* Keep cursor valid */
 
-  assert( cursorHoldsMutex(pCur) );
+  assert( cursorOwnsBtShared(pCur) );
   assert( pBt->inTransaction==TRANS_WRITE );
   assert( (pBt->btsFlags & BTS_READ_ONLY)==0 );
   assert( pCur->curFlags & BTCF_WriteFlag );
@@ -63239,6 +63694,7 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, int bPreserve){
   assert( !hasReadConflicts(p, pCur->pgnoRoot) );
   assert( pCur->aiIdx[pCur->iPage]<pCur->apPage[pCur->iPage]->nCell );
   assert( pCur->eState==CURSOR_VALID );
+  assert( (flags & ~(BTREE_SAVEPOSITION | BTREE_AUXDELETE))==0 );
 
   iCellDepth = pCur->iPage;
   iCellIdx = pCur->aiIdx[iCellDepth];
@@ -63351,7 +63807,7 @@ SQLITE_PRIVATE int sqlite3BtreeDelete(BtCursor *pCur, int bPreserve){
   if( rc==SQLITE_OK ){
     if( bSkipnext ){
       assert( bPreserve && (pCur->iPage==iCellDepth || CORRUPT_DB) );
-      assert( pPage==pCur->apPage[pCur->iPage] );
+      assert( pPage==pCur->apPage[pCur->iPage] || CORRUPT_DB );
       assert( (pPage->nCell>0 || CORRUPT_DB) && iCellIdx<=pPage->nCell );
       pCur->eState = CURSOR_SKIPNEXT;
       if( iCellIdx>=pPage->nCell ){
@@ -63672,6 +64128,14 @@ static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){
     return SQLITE_LOCKED_SHAREDCACHE;
   }
 
+  /*
+  ** It is illegal to drop the sqlite_master table on page 1.  But again,
+  ** this error is caught long before reaching this point.
+  */
+  if( NEVER(iTable<2) ){
+    return SQLITE_CORRUPT_BKPT;
+  }
+
   rc = btreeGetPage(pBt, (Pgno)iTable, &pPage, 0);
   if( rc ) return rc;
   rc = sqlite3BtreeClearTable(p, iTable, 0);
@@ -63682,76 +64146,67 @@ static int btreeDropTable(Btree *p, Pgno iTable, int *piMoved){
 
   *piMoved = 0;
 
-  if( iTable>1 ){
 #ifdef SQLITE_OMIT_AUTOVACUUM
-    freePage(pPage, &rc);
-    releasePage(pPage);
+  freePage(pPage, &rc);
+  releasePage(pPage);
 #else
-    if( pBt->autoVacuum ){
-      Pgno maxRootPgno;
-      sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &maxRootPgno);
+  if( pBt->autoVacuum ){
+    Pgno maxRootPgno;
+    sqlite3BtreeGetMeta(p, BTREE_LARGEST_ROOT_PAGE, &maxRootPgno);
 
-      if( iTable==maxRootPgno ){
-        /* If the table being dropped is the table with the largest root-page
-        ** number in the database, put the root page on the free list. 
-        */
-        freePage(pPage, &rc);
-        releasePage(pPage);
-        if( rc!=SQLITE_OK ){
-          return rc;
-        }
-      }else{
-        /* The table being dropped does not have the largest root-page
-        ** number in the database. So move the page that does into the 
-        ** gap left by the deleted root-page.
-        */
-        MemPage *pMove;
-        releasePage(pPage);
-        rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
-        if( rc!=SQLITE_OK ){
-          return rc;
-        }
-        rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable, 0);
-        releasePage(pMove);
-        if( rc!=SQLITE_OK ){
-          return rc;
-        }
-        pMove = 0;
-        rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
-        freePage(pMove, &rc);
-        releasePage(pMove);
-        if( rc!=SQLITE_OK ){
-          return rc;
-        }
-        *piMoved = maxRootPgno;
-      }
-
-      /* Set the new 'max-root-page' value in the database header. This
-      ** is the old value less one, less one more if that happens to
-      ** be a root-page number, less one again if that is the
-      ** PENDING_BYTE_PAGE.
+    if( iTable==maxRootPgno ){
+      /* If the table being dropped is the table with the largest root-page
+      ** number in the database, put the root page on the free list. 
       */
-      maxRootPgno--;
-      while( maxRootPgno==PENDING_BYTE_PAGE(pBt)
-             || PTRMAP_ISPAGE(pBt, maxRootPgno) ){
-        maxRootPgno--;
-      }
-      assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) );
-
-      rc = sqlite3BtreeUpdateMeta(p, 4, maxRootPgno);
-    }else{
       freePage(pPage, &rc);
       releasePage(pPage);
+      if( rc!=SQLITE_OK ){
+        return rc;
+      }
+    }else{
+      /* The table being dropped does not have the largest root-page
+      ** number in the database. So move the page that does into the 
+      ** gap left by the deleted root-page.
+      */
+      MemPage *pMove;
+      releasePage(pPage);
+      rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
+      if( rc!=SQLITE_OK ){
+        return rc;
+      }
+      rc = relocatePage(pBt, pMove, PTRMAP_ROOTPAGE, 0, iTable, 0);
+      releasePage(pMove);
+      if( rc!=SQLITE_OK ){
+        return rc;
+      }
+      pMove = 0;
+      rc = btreeGetPage(pBt, maxRootPgno, &pMove, 0);
+      freePage(pMove, &rc);
+      releasePage(pMove);
+      if( rc!=SQLITE_OK ){
+        return rc;
+      }
+      *piMoved = maxRootPgno;
     }
-#endif
-  }else{
-    /* If sqlite3BtreeDropTable was called on page 1.
-    ** This really never should happen except in a corrupt
-    ** database. 
+
+    /* Set the new 'max-root-page' value in the database header. This
+    ** is the old value less one, less one more if that happens to
+    ** be a root-page number, less one again if that is the
+    ** PENDING_BYTE_PAGE.
     */
-    zeroPage(pPage, PTF_INTKEY|PTF_LEAF );
+    maxRootPgno--;
+    while( maxRootPgno==PENDING_BYTE_PAGE(pBt)
+           || PTRMAP_ISPAGE(pBt, maxRootPgno) ){
+      maxRootPgno--;
+    }
+    assert( maxRootPgno!=PENDING_BYTE_PAGE(pBt) );
+
+    rc = sqlite3BtreeUpdateMeta(p, 4, maxRootPgno);
+  }else{
+    freePage(pPage, &rc);
     releasePage(pPage);
   }
+#endif
   return rc;  
 }
 SQLITE_PRIVATE int sqlite3BtreeDropTable(Btree *p, int iTable, int *piMoved){
@@ -63938,9 +64393,9 @@ static void checkAppendMsg(
     sqlite3StrAccumAppend(&pCheck->errMsg, "\n", 1);
   }
   if( pCheck->zPfx ){
-    sqlite3XPrintf(&pCheck->errMsg, 0, pCheck->zPfx, pCheck->v1, pCheck->v2);
+    sqlite3XPrintf(&pCheck->errMsg, pCheck->zPfx, pCheck->v1, pCheck->v2);
   }
-  sqlite3VXPrintf(&pCheck->errMsg, 1, zFormat, ap);
+  sqlite3VXPrintf(&pCheck->errMsg, zFormat, ap);
   va_end(ap);
   if( pCheck->errMsg.accError==STRACCUM_NOMEM ){
     pCheck->mallocFailed = 1;
@@ -64441,7 +64896,8 @@ SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(
 
   sqlite3BtreeEnter(p);
   assert( p->inTrans>TRANS_NONE && pBt->inTransaction>TRANS_NONE );
-  assert( (nRef = sqlite3PagerRefcount(pBt->pPager))>=0 );
+  VVA_ONLY( nRef = sqlite3PagerRefcount(pBt->pPager) );
+  assert( nRef>=0 );
   sCheck.pBt = pBt;
   sCheck.pPager = pBt->pPager;
   sCheck.nPage = btreePagecount(sCheck.pBt);
@@ -64454,6 +64910,7 @@ SQLITE_PRIVATE char *sqlite3BtreeIntegrityCheck(
   sCheck.aPgRef = 0;
   sCheck.heap = 0;
   sqlite3StrAccumInit(&sCheck.errMsg, 0, zErr, sizeof(zErr), SQLITE_MAX_LENGTH);
+  sCheck.errMsg.printfFlags = SQLITE_PRINTF_INTERNAL;
   if( sCheck.nPage==0 ){
     goto integrity_ck_cleanup;
   }
@@ -64693,7 +65150,7 @@ SQLITE_PRIVATE int sqlite3BtreeLockTable(Btree *p, int iTab, u8 isWriteLock){
 */
 SQLITE_PRIVATE int sqlite3BtreePutData(BtCursor *pCsr, u32 offset, u32 amt, void *z){
   int rc;
-  assert( cursorHoldsMutex(pCsr) );
+  assert( cursorOwnsBtShared(pCsr) );
   assert( sqlite3_mutex_held(pCsr->pBtree->db->mutex) );
   assert( pCsr->curFlags & BTCF_Incrblob );
 
@@ -64801,6 +65258,15 @@ SQLITE_PRIVATE int sqlite3BtreeIsReadonly(Btree *p){
 */
 SQLITE_PRIVATE int sqlite3HeaderSizeBtree(void){ return ROUND8(sizeof(MemPage)); }
 
+#if !defined(SQLITE_OMIT_SHARED_CACHE)
+/*
+** Return true if the Btree passed as the only argument is sharable.
+*/
+SQLITE_PRIVATE int sqlite3BtreeSharable(Btree *p){
+  return p->sharable;
+}
+#endif
+
 /************** End of btree.c ***********************************************/
 /************** Begin file backup.c ******************************************/
 /*
@@ -65721,6 +66187,7 @@ SQLITE_PRIVATE int sqlite3VdbeChangeEncoding(Mem *pMem, int desiredEnc){
 SQLITE_PRIVATE SQLITE_NOINLINE int sqlite3VdbeMemGrow(Mem *pMem, int n, int bPreserve){
   assert( sqlite3VdbeCheckMemInvariants(pMem) );
   assert( (pMem->flags&MEM_RowSet)==0 );
+  testcase( pMem->db==0 );
 
   /* If the bPreserve flag is set to true, then the memory cell must already
   ** contain a valid string or blob value.  */
@@ -66324,7 +66791,7 @@ SQLITE_PRIVATE void sqlite3VdbeMemSetRowSet(Mem *pMem){
   assert( db!=0 );
   assert( (pMem->flags & MEM_RowSet)==0 );
   sqlite3VdbeMemRelease(pMem);
-  pMem->zMalloc = sqlite3DbMallocRaw(db, 64);
+  pMem->zMalloc = sqlite3DbMallocRawNN(db, 64);
   if( db->mallocFailed ){
     pMem->flags = MEM_Null;
     pMem->szMalloc = 0;
@@ -66829,7 +67296,7 @@ static int valueFromFunction(
   memset(&ctx, 0, sizeof(ctx));
   ctx.pOut = pVal;
   ctx.pFunc = pFunc;
-  pFunc->xFunc(&ctx, nVal, apVal);
+  pFunc->xSFunc(&ctx, nVal, apVal);
   if( ctx.isError ){
     rc = ctx.isError;
     sqlite3ErrorMsg(pCtx->pParse, "%s", sqlite3_value_text(pVal));
@@ -66986,7 +67453,7 @@ static int valueFromExpr(
   return rc;
 
 no_mem:
-  db->mallocFailed = 1;
+  sqlite3OomFault(db);
   sqlite3DbFree(db, zVal);
   assert( *ppVal==0 );
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
@@ -67045,7 +67512,7 @@ static void recordFunc(
   db = sqlite3_context_db_handle(context);
 
   nRet = 1 + nSerial + nVal;
-  aRet = sqlite3DbMallocRaw(db, nRet);
+  aRet = sqlite3DbMallocRawNN(db, nRet);
   if( aRet==0 ){
     sqlite3_result_error_nomem(context);
   }else{
@@ -67497,7 +67964,7 @@ SQLITE_PRIVATE int sqlite3VdbeAddOp3(Vdbe *p, int op, int p1, int p2, int p3){
 
   i = p->nOp;
   assert( p->magic==VDBE_MAGIC_INIT );
-  assert( op>0 && op<0xff );
+  assert( op>=0 && op<0xff );
   if( p->pParse->nOpAlloc<=i ){
     return growOp3(p, op, p1, p2, p3);
   }
@@ -67576,8 +68043,7 @@ SQLITE_PRIVATE void sqlite3VdbeMultiLoad(Vdbe *p, int iDest, const char *zTypes,
   for(i=0; (c = zTypes[i])!=0; i++){
     if( c=='s' ){
       const char *z = va_arg(ap, const char*);
-      int addr = sqlite3VdbeAddOp2(p, z==0 ? OP_Null : OP_String8, 0, iDest++);
-      if( z ) sqlite3VdbeChangeP4(p, addr, z, 0);
+      sqlite3VdbeAddOp4(p, z==0 ? OP_Null : OP_String8, 0, iDest++, 0, z, 0);
     }else{
       assert( c=='i' );
       sqlite3VdbeAddOp2(p, OP_Integer, va_arg(ap, int), iDest++);
@@ -67616,7 +68082,7 @@ SQLITE_PRIVATE int sqlite3VdbeAddOp4Dup8(
   const u8 *zP4,      /* The P4 operand */
   int p4type          /* P4 operand type */
 ){
-  char *p4copy = sqlite3DbMallocRaw(sqlite3VdbeDb(p), 8);
+  char *p4copy = sqlite3DbMallocRawNN(sqlite3VdbeDb(p), 8);
   if( p4copy ) memcpy(p4copy, zP4, 8);
   return sqlite3VdbeAddOp4(p, op, p1, p2, p3, p4copy, p4type);
 }
@@ -67631,8 +68097,7 @@ SQLITE_PRIVATE int sqlite3VdbeAddOp4Dup8(
 */
 SQLITE_PRIVATE void sqlite3VdbeAddParseSchemaOp(Vdbe *p, int iDb, char *zWhere){
   int j;
-  int addr = sqlite3VdbeAddOp3(p, OP_ParseSchema, iDb, 0, 0);
-  sqlite3VdbeChangeP4(p, addr, zWhere, P4_DYNAMIC);
+  sqlite3VdbeAddOp4(p, OP_ParseSchema, iDb, 0, 0, zWhere, P4_DYNAMIC);
   for(j=0; j<p->db->nDb; j++) sqlite3VdbeUsesBtree(p, j);
 }
 
@@ -67652,6 +68117,21 @@ SQLITE_PRIVATE int sqlite3VdbeAddOp4Int(
   return addr;
 }
 
+/* Insert the end of a co-routine
+*/
+SQLITE_PRIVATE void sqlite3VdbeEndCoroutine(Vdbe *v, int regYield){
+  sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield);
+
+  /* Clear the temporary register cache, thereby ensuring that each
+  ** co-routine has its own independent set of registers, because co-routines
+  ** might expect their registers to be preserved across an OP_Yield, and
+  ** that could cause problems if two or more co-routines are using the same
+  ** temporary register.
+  */
+  v->pParse->nTempReg = 0;
+  v->pParse->nRangeReg = 0;
+}
+
 /*
 ** Create a new symbolic label for an instruction that has yet to be
 ** coded.  The symbolic label is really just a negative number.  The
@@ -67862,7 +68342,7 @@ static void resolveP2Values(Vdbe *p, int *pMaxFuncArgs){
   for(pOp=p->aOp, i=p->nOp-1; i>=0; i--, pOp++){
     u8 opcode = pOp->opcode;
 
-    /* NOTE: Be sure to update mkopcodeh.awk when adding or removing
+    /* NOTE: Be sure to update mkopcodeh.tcl when adding or removing
     ** cases from this switch! */
     switch( opcode ){
       case OP_Transaction: {
@@ -67933,6 +68413,20 @@ SQLITE_PRIVATE int sqlite3VdbeCurrentAddr(Vdbe *p){
   return p->nOp;
 }
 
+/*
+** Verify that at least N opcode slots are available in p without
+** having to malloc for more space (except when compiled using
+** SQLITE_TEST_REALLOC_STRESS).  This interface is used during testing
+** to verify that certain calls to sqlite3VdbeAddOpList() can never
+** fail due to a OOM fault and hence that the return value from
+** sqlite3VdbeAddOpList() will always be non-NULL.
+*/
+#if defined(SQLITE_DEBUG) && !defined(SQLITE_TEST_REALLOC_STRESS)
+SQLITE_PRIVATE void sqlite3VdbeVerifyNoMallocRequired(Vdbe *p, int N){
+  assert( p->nOp + N <= p->pParse->nOpAlloc );
+}
+#endif
+
 /*
 ** This function returns a pointer to the array of opcodes associated with
 ** the Vdbe passed as the first argument. It is the callers responsibility
@@ -67958,24 +68452,34 @@ SQLITE_PRIVATE VdbeOp *sqlite3VdbeTakeOpArray(Vdbe *p, int *pnOp, int *pnMaxArg)
 }
 
 /*
-** Add a whole list of operations to the operation stack.  Return the
-** address of the first operation added.
+** Add a whole list of operations to the operation stack.  Return a
+** pointer to the first operation inserted.
+**
+** Non-zero P2 arguments to jump instructions are automatically adjusted
+** so that the jump target is relative to the first operation inserted.
 */
-SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp, int iLineno){
-  int addr, i;
-  VdbeOp *pOut;
+SQLITE_PRIVATE VdbeOp *sqlite3VdbeAddOpList(
+  Vdbe *p,                     /* Add opcodes to the prepared statement */
+  int nOp,                     /* Number of opcodes to add */
+  VdbeOpList const *aOp,       /* The opcodes to be added */
+  int iLineno                  /* Source-file line number of first opcode */
+){
+  int i;
+  VdbeOp *pOut, *pFirst;
   assert( nOp>0 );
   assert( p->magic==VDBE_MAGIC_INIT );
   if( p->nOp + nOp > p->pParse->nOpAlloc && growOpArray(p, nOp) ){
     return 0;
   }
-  addr = p->nOp;
-  pOut = &p->aOp[addr];
+  pFirst = pOut = &p->aOp[p->nOp];
   for(i=0; i<nOp; i++, aOp++, pOut++){
     pOut->opcode = aOp->opcode;
     pOut->p1 = aOp->p1;
     pOut->p2 = aOp->p2;
     assert( aOp->p2>=0 );
+    if( (sqlite3OpcodeProperty[aOp->opcode] & OPFLG_JUMP)!=0 && aOp->p2>0 ){
+      pOut->p2 += p->nOp;
+    }
     pOut->p3 = aOp->p3;
     pOut->p4type = P4_NOTUSED;
     pOut->p4.p = 0;
@@ -67990,12 +68494,12 @@ SQLITE_PRIVATE int sqlite3VdbeAddOpList(Vdbe *p, int nOp, VdbeOpList const *aOp,
 #endif
 #ifdef SQLITE_DEBUG
     if( p->db->flags & SQLITE_VdbeAddopTrace ){
-      sqlite3VdbePrintOp(0, i+addr, &p->aOp[i+addr]);
+      sqlite3VdbePrintOp(0, i+p->nOp, &p->aOp[i+p->nOp]);
     }
 #endif
   }
   p->nOp += nOp;
-  return addr;
+  return pFirst;
 }
 
 #if defined(SQLITE_ENABLE_STMT_SCANSTATUS)
@@ -68043,7 +68547,7 @@ SQLITE_PRIVATE void sqlite3VdbeChangeP3(Vdbe *p, u32 addr, int val){
   sqlite3VdbeGetOp(p,addr)->p3 = val;
 }
 SQLITE_PRIVATE void sqlite3VdbeChangeP5(Vdbe *p, u8 p5){
-  sqlite3VdbeGetOp(p,-1)->p5 = p5;
+  if( !p->db->mallocFailed ) p->aOp[p->nOp-1].p5 = p5;
 }
 
 /*
@@ -68131,7 +68635,7 @@ static void vdbeFreeOpArray(sqlite3 *db, Op *aOp, int nOp){
   if( aOp ){
     Op *pOp;
     for(pOp=aOp; pOp<&aOp[nOp]; pOp++){
-      freeP4(db, pOp->p4type, pOp->p4.p);
+      if( pOp->p4type ) freeP4(db, pOp->p4type, pOp->p4.p);
 #ifdef SQLITE_ENABLE_EXPLAIN_COMMENTS
       sqlite3DbFree(db, pOp->zComment);
 #endif     
@@ -68153,14 +68657,16 @@ SQLITE_PRIVATE void sqlite3VdbeLinkSubProgram(Vdbe *pVdbe, SubProgram *p){
 /*
 ** Change the opcode at addr into OP_Noop
 */
-SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe *p, int addr){
-  if( addr<p->nOp ){
-    VdbeOp *pOp = &p->aOp[addr];
-    sqlite3 *db = p->db;
-    freeP4(db, pOp->p4type, pOp->p4.p);
-    memset(pOp, 0, sizeof(pOp[0]));
-    pOp->opcode = OP_Noop;
-  }
+SQLITE_PRIVATE int sqlite3VdbeChangeToNoop(Vdbe *p, int addr){
+  VdbeOp *pOp;
+  if( p->db->mallocFailed ) return 0;
+  assert( addr>=0 && addr<p->nOp );
+  pOp = &p->aOp[addr];
+  freeP4(p->db, pOp->p4type, pOp->p4.p);
+  pOp->p4type = P4_NOTUSED;
+  pOp->p4.z = 0;
+  pOp->opcode = OP_Noop;
+  return 1;
 }
 
 /*
@@ -68169,8 +68675,7 @@ SQLITE_PRIVATE void sqlite3VdbeChangeToNoop(Vdbe *p, int addr){
 */
 SQLITE_PRIVATE int sqlite3VdbeDeletePriorOpcode(Vdbe *p, u8 op){
   if( (p->nOp-1)>(p->pParse->iFixedOp) && p->aOp[p->nOp-1].opcode==op ){
-    sqlite3VdbeChangeToNoop(p, p->nOp-1);
-    return 1;
+    return sqlite3VdbeChangeToNoop(p, p->nOp-1);
   }else{
     return 0;
   }
@@ -68193,16 +68698,34 @@ SQLITE_PRIVATE int sqlite3VdbeDeletePriorOpcode(Vdbe *p, u8 op){
 **
 ** If addr<0 then change P4 on the most recently inserted instruction.
 */
+static void SQLITE_NOINLINE vdbeChangeP4Full(
+  Vdbe *p,
+  Op *pOp,
+  const char *zP4,
+  int n
+){
+  if( pOp->p4type ){
+    freeP4(p->db, pOp->p4type, pOp->p4.p);
+    pOp->p4type = 0;
+    pOp->p4.p = 0;
+  }
+  if( n<0 ){
+    sqlite3VdbeChangeP4(p, (int)(pOp - p->aOp), zP4, n);
+  }else{
+    if( n==0 ) n = sqlite3Strlen30(zP4);
+    pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n);
+    pOp->p4type = P4_DYNAMIC;
+  }
+}
 SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int n){
   Op *pOp;
   sqlite3 *db;
   assert( p!=0 );
   db = p->db;
   assert( p->magic==VDBE_MAGIC_INIT );
-  if( p->aOp==0 || db->mallocFailed ){
-    if( n!=P4_VTAB ){
-      freeP4(db, n, (void*)*(char**)&zP4);
-    }
+  assert( p->aOp!=0 || db->mallocFailed );
+  if( db->mallocFailed ){
+    if( n!=P4_VTAB ) freeP4(db, n, (void*)*(char**)&zP4);
     return;
   }
   assert( p->nOp>0 );
@@ -68211,43 +68734,20 @@ SQLITE_PRIVATE void sqlite3VdbeChangeP4(Vdbe *p, int addr, const char *zP4, int
     addr = p->nOp - 1;
   }
   pOp = &p->aOp[addr];
-  assert( pOp->p4type==P4_NOTUSED
-       || pOp->p4type==P4_INT32
-       || pOp->p4type==P4_KEYINFO );
-  freeP4(db, pOp->p4type, pOp->p4.p);
-  pOp->p4.p = 0;
+  if( n>=0 || pOp->p4type ){
+    vdbeChangeP4Full(p, pOp, zP4, n);
+    return;
+  }
   if( n==P4_INT32 ){
     /* Note: this cast is safe, because the origin data point was an int
     ** that was cast to a (const char *). */
     pOp->p4.i = SQLITE_PTR_TO_INT(zP4);
     pOp->p4type = P4_INT32;
-  }else if( zP4==0 ){
-    pOp->p4.p = 0;
-    pOp->p4type = P4_NOTUSED;
-  }else if( n==P4_KEYINFO ){
-    pOp->p4.p = (void*)zP4;
-    pOp->p4type = P4_KEYINFO;
-#ifdef SQLITE_ENABLE_CURSOR_HINTS
-  }else if( n==P4_EXPR ){
-    /* Responsibility for deleting the Expr tree is handed over to the
-    ** VDBE by this operation.  The caller should have already invoked
-    ** sqlite3ExprDup() or whatever other routine is needed to make a 
-    ** private copy of the tree. */
-    pOp->p4.pExpr = (Expr*)zP4;
-    pOp->p4type = P4_EXPR;
-#endif
-  }else if( n==P4_VTAB ){
-    pOp->p4.p = (void*)zP4;
-    pOp->p4type = P4_VTAB;
-    sqlite3VtabLock((VTable *)zP4);
-    assert( ((VTable *)zP4)->db==p->db );
-  }else if( n<0 ){
+  }else if( zP4!=0 ){
+    assert( n<0 );
     pOp->p4.p = (void*)zP4;
     pOp->p4type = (signed char)n;
-  }else{
-    if( n==0 ) n = sqlite3Strlen30(zP4);
-    pOp->p4.z = sqlite3DbStrNDup(p->db, zP4, n);
-    pOp->p4type = P4_DYNAMIC;
+    if( n==P4_VTAB ) sqlite3VtabLock((VTable*)zP4);
   }
 }
 
@@ -68431,28 +68931,27 @@ static int displayComment(
 ** Translate the P4.pExpr value for an OP_CursorHint opcode into text
 ** that can be displayed in the P4 column of EXPLAIN output.
 */
-static int displayP4Expr(int nTemp, char *zTemp, Expr *pExpr){
+static void displayP4Expr(StrAccum *p, Expr *pExpr){
   const char *zOp = 0;
-  int n;
   switch( pExpr->op ){
     case TK_STRING:
-      sqlite3_snprintf(nTemp, zTemp, "%Q", pExpr->u.zToken);
+      sqlite3XPrintf(p, "%Q", pExpr->u.zToken);
       break;
     case TK_INTEGER:
-      sqlite3_snprintf(nTemp, zTemp, "%d", pExpr->u.iValue);
+      sqlite3XPrintf(p, "%d", pExpr->u.iValue);
       break;
     case TK_NULL:
-      sqlite3_snprintf(nTemp, zTemp, "NULL");
+      sqlite3XPrintf(p, "NULL");
       break;
     case TK_REGISTER: {
-      sqlite3_snprintf(nTemp, zTemp, "r[%d]", pExpr->iTable);
+      sqlite3XPrintf(p, "r[%d]", pExpr->iTable);
       break;
     }
     case TK_COLUMN: {
       if( pExpr->iColumn<0 ){
-        sqlite3_snprintf(nTemp, zTemp, "rowid");
+        sqlite3XPrintf(p, "rowid");
       }else{
-        sqlite3_snprintf(nTemp, zTemp, "c%d", (int)pExpr->iColumn);
+        sqlite3XPrintf(p, "c%d", (int)pExpr->iColumn);
       }
       break;
     }
@@ -68484,21 +68983,19 @@ static int displayP4Expr(int nTemp, char *zTemp, Expr *pExpr){
     case TK_NOTNULL: zOp = "NOTNULL"; break;
 
     default:
-      sqlite3_snprintf(nTemp, zTemp, "%s", "expr");
+      sqlite3XPrintf(p, "%s", "expr");
       break;
   }
 
   if( zOp ){
-    sqlite3_snprintf(nTemp, zTemp, "%s(", zOp);
-    n = sqlite3Strlen30(zTemp);
-    n += displayP4Expr(nTemp-n, zTemp+n, pExpr->pLeft);
-    if( n<nTemp-1 && pExpr->pRight ){
-      zTemp[n++] = ',';
-      n += displayP4Expr(nTemp-n, zTemp+n, pExpr->pRight);
+    sqlite3XPrintf(p, "%s(", zOp);
+    displayP4Expr(p, pExpr->pLeft);
+    if( pExpr->pRight ){
+      sqlite3StrAccumAppend(p, ",", 1);
+      displayP4Expr(p, pExpr->pRight);
     }
-    sqlite3_snprintf(nTemp-n, zTemp+n, ")");
+    sqlite3StrAccumAppend(p, ")", 1);
   }
-  return sqlite3Strlen30(zTemp);
 }
 #endif /* VDBE_DISPLAY_P4 && defined(SQLITE_ENABLE_CURSOR_HINTS) */
 
@@ -68510,72 +69007,57 @@ static int displayP4Expr(int nTemp, char *zTemp, Expr *pExpr){
 */
 static char *displayP4(Op *pOp, char *zTemp, int nTemp){
   char *zP4 = zTemp;
+  StrAccum x;
   assert( nTemp>=20 );
+  sqlite3StrAccumInit(&x, 0, zTemp, nTemp, 0);
   switch( pOp->p4type ){
     case P4_KEYINFO: {
-      int i, j;
+      int j;
       KeyInfo *pKeyInfo = pOp->p4.pKeyInfo;
       assert( pKeyInfo->aSortOrder!=0 );
-      sqlite3_snprintf(nTemp, zTemp, "k(%d", pKeyInfo->nField);
-      i = sqlite3Strlen30(zTemp);
+      sqlite3XPrintf(&x, "k(%d", pKeyInfo->nField);
       for(j=0; j<pKeyInfo->nField; j++){
         CollSeq *pColl = pKeyInfo->aColl[j];
-        const char *zColl = pColl ? pColl->zName : "nil";
-        int n = sqlite3Strlen30(zColl);
-        if( n==6 && memcmp(zColl,"BINARY",6)==0 ){
-          zColl = "B";
-          n = 1;
-        }
-        if( i+n>nTemp-7 ){
-          memcpy(&zTemp[i],",...",4);
-          i += 4;
-          break;
-        }
-        zTemp[i++] = ',';
-        if( pKeyInfo->aSortOrder[j] ){
-          zTemp[i++] = '-';
-        }
-        memcpy(&zTemp[i], zColl, n+1);
-        i += n;
+        const char *zColl = pColl ? pColl->zName : "";
+        if( strcmp(zColl, "BINARY")==0 ) zColl = "B";
+        sqlite3XPrintf(&x, ",%s%s", pKeyInfo->aSortOrder[j] ? "-" : "", zColl);
       }
-      zTemp[i++] = ')';
-      zTemp[i] = 0;
-      assert( i<nTemp );
+      sqlite3StrAccumAppend(&x, ")", 1);
       break;
     }
 #ifdef SQLITE_ENABLE_CURSOR_HINTS
     case P4_EXPR: {
-      displayP4Expr(nTemp, zTemp, pOp->p4.pExpr);
+      displayP4Expr(&x, pOp->p4.pExpr);
       break;
     }
 #endif
     case P4_COLLSEQ: {
       CollSeq *pColl = pOp->p4.pColl;
-      sqlite3_snprintf(nTemp, zTemp, "(%.20s)", pColl->zName);
+      sqlite3XPrintf(&x, "(%.20s)", pColl->zName);
       break;
     }
     case P4_FUNCDEF: {
       FuncDef *pDef = pOp->p4.pFunc;
-      sqlite3_snprintf(nTemp, zTemp, "%s(%d)", pDef->zName, pDef->nArg);
+      sqlite3XPrintf(&x, "%s(%d)", pDef->zName, pDef->nArg);
       break;
     }
 #ifdef SQLITE_DEBUG
     case P4_FUNCCTX: {
       FuncDef *pDef = pOp->p4.pCtx->pFunc;
-      sqlite3_snprintf(nTemp, zTemp, "%s(%d)", pDef->zName, pDef->nArg);
+      sqlite3XPrintf(&x, "%s(%d)", pDef->zName, pDef->nArg);
       break;
     }
 #endif
     case P4_INT64: {
-      sqlite3_snprintf(nTemp, zTemp, "%lld", *pOp->p4.pI64);
+      sqlite3XPrintf(&x, "%lld", *pOp->p4.pI64);
       break;
     }
     case P4_INT32: {
-      sqlite3_snprintf(nTemp, zTemp, "%d", pOp->p4.i);
+      sqlite3XPrintf(&x, "%d", pOp->p4.i);
       break;
     }
     case P4_REAL: {
-      sqlite3_snprintf(nTemp, zTemp, "%.16g", *pOp->p4.pReal);
+      sqlite3XPrintf(&x, "%.16g", *pOp->p4.pReal);
       break;
     }
     case P4_MEM: {
@@ -68583,11 +69065,11 @@ static char *displayP4(Op *pOp, char *zTemp, int nTemp){
       if( pMem->flags & MEM_Str ){
         zP4 = pMem->z;
       }else if( pMem->flags & MEM_Int ){
-        sqlite3_snprintf(nTemp, zTemp, "%lld", pMem->u.i);
+        sqlite3XPrintf(&x, "%lld", pMem->u.i);
       }else if( pMem->flags & MEM_Real ){
-        sqlite3_snprintf(nTemp, zTemp, "%.16g", pMem->u.r);
+        sqlite3XPrintf(&x, "%.16g", pMem->u.r);
       }else if( pMem->flags & MEM_Null ){
-        sqlite3_snprintf(nTemp, zTemp, "NULL");
+        zP4 = "NULL";
       }else{
         assert( pMem->flags & MEM_Blob );
         zP4 = "(blob)";
@@ -68597,16 +69079,24 @@ static char *displayP4(Op *pOp, char *zTemp, int nTemp){
 #ifndef SQLITE_OMIT_VIRTUALTABLE
     case P4_VTAB: {
       sqlite3_vtab *pVtab = pOp->p4.pVtab->pVtab;
-      sqlite3_snprintf(nTemp, zTemp, "vtab:%p", pVtab);
+      sqlite3XPrintf(&x, "vtab:%p", pVtab);
       break;
     }
 #endif
     case P4_INTARRAY: {
-      sqlite3_snprintf(nTemp, zTemp, "intarray");
+      int i;
+      int *ai = pOp->p4.ai;
+      int n = ai[0];   /* The first element of an INTARRAY is always the
+                       ** count of the number of elements to follow */
+      for(i=1; i<n; i++){
+        sqlite3XPrintf(&x, ",%d", ai[i]);
+      }
+      zTemp[0] = '[';
+      sqlite3StrAccumAppend(&x, "]", 1);
       break;
     }
     case P4_SUBPROGRAM: {
-      sqlite3_snprintf(nTemp, zTemp, "program");
+      sqlite3XPrintf(&x, "program");
       break;
     }
     case P4_ADVANCE: {
@@ -68621,6 +69111,7 @@ static char *displayP4(Op *pOp, char *zTemp, int nTemp){
       }
     }
   }
+  sqlite3StrAccumFinish(&x);
   assert( zP4!=0 );
   return zP4;
 }
@@ -68643,7 +69134,7 @@ SQLITE_PRIVATE void sqlite3VdbeUsesBtree(Vdbe *p, int i){
   }
 }
 
-#if !defined(SQLITE_OMIT_SHARED_CACHE) && SQLITE_THREADSAFE>0
+#if !defined(SQLITE_OMIT_SHARED_CACHE)
 /*
 ** If SQLite is compiled to support shared-cache mode and to be threadsafe,
 ** this routine obtains the mutex associated with each BtShared structure
@@ -68740,7 +69231,6 @@ static void releaseMemArray(Mem *p, int N){
   if( p && N ){
     Mem *pEnd = &p[N];
     sqlite3 *db = p->db;
-    u8 malloc_failed = db->mallocFailed;
     if( db->pnBytesFreed ){
       do{
         if( p->szMalloc ) sqlite3DbFree(db, p->zMalloc);
@@ -68776,7 +69266,6 @@ static void releaseMemArray(Mem *p, int N){
 
       p->flags = MEM_Undefined;
     }while( (++p)<pEnd );
-    db->mallocFailed = malloc_failed;
   }
 }
 
@@ -68837,7 +69326,7 @@ SQLITE_PRIVATE int sqlite3VdbeList(
   if( p->rc==SQLITE_NOMEM ){
     /* This happens if a malloc() inside a call to sqlite3_column_text() or
     ** sqlite3_column_text16() failed.  */
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
     return SQLITE_ERROR;
   }
 
@@ -69035,41 +69524,43 @@ SQLITE_PRIVATE void sqlite3VdbeIOTraceSql(Vdbe *p){
 }
 #endif /* !SQLITE_OMIT_TRACE && SQLITE_ENABLE_IOTRACE */
 
-/*
-** Allocate space from a fixed size buffer and return a pointer to
-** that space.  If insufficient space is available, return NULL.
+/* An instance of this object describes bulk memory available for use
+** by subcomponents of a prepared statement.  Space is allocated out
+** of a ReusableSpace object by the allocSpace() routine below.
+*/
+struct ReusableSpace {
+  u8 *pSpace;          /* Available memory */
+  int nFree;           /* Bytes of available memory */
+  int nNeeded;         /* Total bytes that could not be allocated */
+};
+
+/* Try to allocate nByte bytes of 8-byte aligned bulk memory for pBuf
+** from the ReusableSpace object.  Return a pointer to the allocated
+** memory on success.  If insufficient memory is available in the
+** ReusableSpace object, increase the ReusableSpace.nNeeded
+** value by the amount needed and return NULL.
 **
-** The pBuf parameter is the initial value of a pointer which will
-** receive the new memory.  pBuf is normally NULL.  If pBuf is not
-** NULL, it means that memory space has already been allocated and that
-** this routine should not allocate any new memory.  When pBuf is not
-** NULL simply return pBuf.  Only allocate new memory space when pBuf
-** is NULL.
+** If pBuf is not initially NULL, that means that the memory has already
+** been allocated by a prior call to this routine, so just return a copy
+** of pBuf and leave ReusableSpace unchanged.
 **
-** nByte is the number of bytes of space needed.
-**
-** pFrom points to *pnFrom bytes of available space.  New space is allocated
-** from the end of the pFrom buffer and *pnFrom is decremented.
-**
-** *pnNeeded is a counter of the number of bytes of space that have failed
-** to allocate.  If there is insufficient space in pFrom to satisfy the
-** request, then increment *pnNeeded by the amount of the request.
+** This allocator is employed to repurpose unused slots at the end of the
+** opcode array of prepared state for other memory needs of the prepared
+** statement.
 */
 static void *allocSpace(
-  void *pBuf,          /* Where return pointer will be stored */
-  int nByte,           /* Number of bytes to allocate */
-  u8 *pFrom,           /* Memory available for allocation */
-  int *pnFrom,         /* IN/OUT: Space available at pFrom */
-  int *pnNeeded        /* If allocation cannot be made, increment *pnByte */
+  struct ReusableSpace *p,  /* Bulk memory available for allocation */
+  void *pBuf,               /* Pointer to a prior allocation */
+  int nByte                 /* Bytes of memory needed */
 ){
-  assert( EIGHT_BYTE_ALIGNMENT(pFrom) );
+  assert( EIGHT_BYTE_ALIGNMENT(p->pSpace) );
   if( pBuf==0 ){
     nByte = ROUND8(nByte);
-    if( nByte <= *pnFrom ){
-      *pnFrom -= nByte;
-      pBuf = &pFrom[*pnFrom];
+    if( nByte <= p->nFree ){
+      p->nFree -= nByte;
+      pBuf = &p->pSpace[p->nFree];
     }else{
-      *pnNeeded += nByte;
+      p->nNeeded += nByte;
     }
   }
   assert( EIGHT_BYTE_ALIGNMENT(pBuf) );
@@ -69102,7 +69593,6 @@ SQLITE_PRIVATE void sqlite3VdbeRewind(Vdbe *p){
   p->pc = -1;
   p->rc = SQLITE_OK;
   p->errorAction = OE_Abort;
-  p->magic = VDBE_MAGIC_RUN;
   p->nChange = 0;
   p->cacheCtr = 1;
   p->minWriteFileFormat = 255;
@@ -69145,9 +69635,7 @@ SQLITE_PRIVATE void sqlite3VdbeMakeReady(
   int nArg;                      /* Number of arguments in subprograms */
   int nOnce;                     /* Number of OP_Once instructions */
   int n;                         /* Loop counter */
-  int nFree;                     /* Available free space */
-  u8 *zCsr;                      /* Memory available for allocation */
-  int nByte;                     /* How much extra memory is needed */
+  struct ReusableSpace x;        /* Reusable bulk memory */
 
   assert( p!=0 );
   assert( p->nOp>0 );
@@ -69165,7 +69653,7 @@ SQLITE_PRIVATE void sqlite3VdbeMakeReady(
   
   /* For each cursor required, also allocate a memory cell. Memory
   ** cells (nMem+1-nCursor)..nMem, inclusive, will never be used by
-  ** the vdbe program. Instead they are used to allocate space for
+  ** the vdbe program. Instead they are used to allocate memory for
   ** VdbeCursor/BtCursor structures. The blob of memory associated with 
   ** cursor 0 is stored in memory cell nMem. Memory cell (nMem-1)
   ** stores the blob of memory associated with cursor 1, etc.
@@ -69174,20 +69662,18 @@ SQLITE_PRIVATE void sqlite3VdbeMakeReady(
   */
   nMem += nCursor;
 
-  /* zCsr will initially point to nFree bytes of unused space at the
-  ** end of the opcode array, p->aOp.  The computation of nFree is
-  ** conservative - it might be smaller than the true number of free
-  ** bytes, but never larger.  nFree must be a multiple of 8 - it is
-  ** rounded down if is not.
+  /* Figure out how much reusable memory is available at the end of the
+  ** opcode array.  This extra memory will be reallocated for other elements
+  ** of the prepared statement.
   */
-  n = ROUND8(sizeof(Op)*p->nOp);              /* Bytes of opcode space used */
-  zCsr = &((u8*)p->aOp)[n];                   /* Unused opcode space */
-  assert( EIGHT_BYTE_ALIGNMENT(zCsr) );
-  nFree = ROUNDDOWN8(pParse->szOpAlloc - n);  /* Bytes of unused space */
-  assert( nFree>=0 );
-  if( nFree>0 ){
-    memset(zCsr, 0, nFree);
-    assert( EIGHT_BYTE_ALIGNMENT(&zCsr[nFree]) );
+  n = ROUND8(sizeof(Op)*p->nOp);              /* Bytes of opcode memory used */
+  x.pSpace = &((u8*)p->aOp)[n];               /* Unused opcode memory */
+  assert( EIGHT_BYTE_ALIGNMENT(x.pSpace) );
+  x.nFree = ROUNDDOWN8(pParse->szOpAlloc - n);  /* Bytes of unused memory */
+  assert( x.nFree>=0 );
+  if( x.nFree>0 ){
+    memset(x.pSpace, 0, x.nFree);
+    assert( EIGHT_BYTE_ALIGNMENT(&x.pSpace[x.nFree]) );
   }
 
   resolveP2Values(p, &nArg);
@@ -69197,34 +69683,30 @@ SQLITE_PRIVATE void sqlite3VdbeMakeReady(
   }
   p->expired = 0;
 
-  /* Memory for registers, parameters, cursor, etc, is allocated in two
-  ** passes.  On the first pass, we try to reuse unused space at the 
+  /* Memory for registers, parameters, cursor, etc, is allocated in one or two
+  ** passes.  On the first pass, we try to reuse unused memory at the 
   ** end of the opcode array.  If we are unable to satisfy all memory
   ** requirements by reusing the opcode array tail, then the second
-  ** pass will fill in the rest using a fresh allocation.  
+  ** pass will fill in the remainder using a fresh memory allocation.  
   **
   ** This two-pass approach that reuses as much memory as possible from
-  ** the leftover space at the end of the opcode array can significantly
+  ** the leftover memory at the end of the opcode array.  This can significantly
   ** reduce the amount of memory held by a prepared statement.
   */
   do {
-    nByte = 0;
-    p->aMem = allocSpace(p->aMem, nMem*sizeof(Mem), zCsr, &nFree, &nByte);
-    p->aVar = allocSpace(p->aVar, nVar*sizeof(Mem), zCsr, &nFree, &nByte);
-    p->apArg = allocSpace(p->apArg, nArg*sizeof(Mem*), zCsr, &nFree, &nByte);
-    p->azVar = allocSpace(p->azVar, nVar*sizeof(char*), zCsr, &nFree, &nByte);
-    p->apCsr = allocSpace(p->apCsr, nCursor*sizeof(VdbeCursor*),
-                          zCsr, &nFree, &nByte);
-    p->aOnceFlag = allocSpace(p->aOnceFlag, nOnce, zCsr, &nFree, &nByte);
+    x.nNeeded = 0;
+    p->aMem = allocSpace(&x, p->aMem, nMem*sizeof(Mem));
+    p->aVar = allocSpace(&x, p->aVar, nVar*sizeof(Mem));
+    p->apArg = allocSpace(&x, p->apArg, nArg*sizeof(Mem*));
+    p->apCsr = allocSpace(&x, p->apCsr, nCursor*sizeof(VdbeCursor*));
+    p->aOnceFlag = allocSpace(&x, p->aOnceFlag, nOnce);
 #ifdef SQLITE_ENABLE_STMT_SCANSTATUS
-    p->anExec = allocSpace(p->anExec, p->nOp*sizeof(i64), zCsr, &nFree, &nByte);
+    p->anExec = allocSpace(&x, p->anExec, p->nOp*sizeof(i64));
 #endif
-    if( nByte ){
-      p->pFree = sqlite3DbMallocZero(db, nByte);
-    }
-    zCsr = p->pFree;
-    nFree = nByte;
-  }while( nByte && !db->mallocFailed );
+    if( x.nNeeded==0 ) break;
+    x.pSpace = p->pFree = sqlite3DbMallocZero(db, x.nNeeded);
+    x.nFree = x.nNeeded;
+  }while( !db->mallocFailed );
 
   p->nCursor = nCursor;
   p->nOnceFlag = nOnce;
@@ -69235,11 +69717,10 @@ SQLITE_PRIVATE void sqlite3VdbeMakeReady(
       p->aVar[n].db = db;
     }
   }
-  if( p->azVar && pParse->nzVar>0 ){
-    p->nzVar = pParse->nzVar;
-    memcpy(p->azVar, pParse->azVar, p->nzVar*sizeof(p->azVar[0]));
-    memset(pParse->azVar, 0, pParse->nzVar*sizeof(pParse->azVar[0]));
-  }
+  p->nzVar = pParse->nzVar;
+  p->azVar = pParse->azVar;
+  pParse->nzVar =  0;
+  pParse->azVar = 0;
   if( p->aMem ){
     p->aMem--;                      /* aMem[] goes from 1..nMem */
     p->nMem = nMem;                 /*       not from 0..nMem-1 */
@@ -69838,7 +70319,7 @@ SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){
   ** one, or the complete transaction if there is no statement transaction.
   */
 
-  if( p->db->mallocFailed ){
+  if( db->mallocFailed ){
     p->rc = SQLITE_NOMEM;
   }
   if( p->aOnceFlag ) memset(p->aOnceFlag, 0, p->nOnceFlag);
@@ -69999,7 +70480,7 @@ SQLITE_PRIVATE int sqlite3VdbeHalt(Vdbe *p){
   }
   p->magic = VDBE_MAGIC_HALT;
   checkActiveVdbeCnt(db);
-  if( p->db->mallocFailed ){
+  if( db->mallocFailed ){
     p->rc = SQLITE_NOMEM;
   }
 
@@ -70036,12 +70517,12 @@ SQLITE_PRIVATE int sqlite3VdbeTransferError(Vdbe *p){
   sqlite3 *db = p->db;
   int rc = p->rc;
   if( p->zErrMsg ){
-    u8 mallocFailed = db->mallocFailed;
+    db->bBenignMalloc++;
     sqlite3BeginBenignMalloc();
     if( db->pErr==0 ) db->pErr = sqlite3ValueNew(db);
     sqlite3ValueSetStr(db->pErr, -1, p->zErrMsg, SQLITE_UTF8, SQLITE_TRANSIENT);
     sqlite3EndBenignMalloc();
-    db->mallocFailed = mallocFailed;
+    db->bBenignMalloc--;
     db->errCode = rc;
   }else{
     sqlite3Error(db, rc);
@@ -70226,6 +70707,7 @@ SQLITE_PRIVATE void sqlite3VdbeClearObject(sqlite3 *db, Vdbe *p){
     sqlite3DbFree(db, pSub);
   }
   for(i=p->nzVar-1; i>=0; i--) sqlite3DbFree(db, p->azVar[i]);
+  sqlite3DbFree(db, p->azVar);
   vdbeFreeOpArray(db, p->aOp, p->nOp);
   sqlite3DbFree(db, p->aColName);
   sqlite3DbFree(db, p->zSql);
@@ -70329,9 +70811,16 @@ SQLITE_PRIVATE int sqlite3VdbeCursorRestore(VdbeCursor *p){
 ** If the cursor is already pointing to the correct row and that row has
 ** not been deleted out from under the cursor, then this routine is a no-op.
 */
-SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor *p){
+SQLITE_PRIVATE int sqlite3VdbeCursorMoveto(VdbeCursor **pp, int *piCol){
+  VdbeCursor *p = *pp;
   if( p->eCurType==CURTYPE_BTREE ){
     if( p->deferredMoveto ){
+      int iMap;
+      if( p->aAltMap && (iMap = p->aAltMap[1+*piCol])>0 ){
+        *pp = p->pAltCursor;
+        *piCol = iMap - 1;
+        return SQLITE_OK;
+      }
       return handleDeferredMoveto(p);
     }
     if( sqlite3BtreeCursorHasMoved(p->uc.pCursor) ){
@@ -70970,9 +71459,9 @@ static int vdbeCompareMemString(
     v2 = sqlite3ValueText((sqlite3_value*)&c2, pColl->enc);
     n2 = v2==0 ? 0 : c2.n;
     rc = pColl->xCmp(pColl->pUser, n1, v1, n2, v2);
+    if( (v1==0 || v2==0) && prcErr ) *prcErr = SQLITE_NOMEM;
     sqlite3VdbeMemRelease(&c1);
     sqlite3VdbeMemRelease(&c2);
-    if( (v1==0 || v2==0) && prcErr ) *prcErr = SQLITE_NOMEM;
     return rc;
   }
 }
@@ -71760,11 +72249,13 @@ SQLITE_PRIVATE void sqlite3VdbeSetVarmask(Vdbe *v, int iVar){
 ** in memory obtained from sqlite3DbMalloc).
 */
 SQLITE_PRIVATE void sqlite3VtabImportErrmsg(Vdbe *p, sqlite3_vtab *pVtab){
-  sqlite3 *db = p->db;
-  sqlite3DbFree(db, p->zErrMsg);
-  p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg);
-  sqlite3_free(pVtab->zErrMsg);
-  pVtab->zErrMsg = 0;
+  if( pVtab->zErrMsg ){
+    sqlite3 *db = p->db;
+    sqlite3DbFree(db, p->zErrMsg);
+    p->zErrMsg = sqlite3DbStrDup(db, pVtab->zErrMsg);
+    sqlite3_free(pVtab->zErrMsg);
+    pVtab->zErrMsg = 0;
+  }
 }
 #endif /* SQLITE_OMIT_VIRTUALTABLE */
 
@@ -71960,7 +72451,8 @@ SQLITE_API sqlite_int64 SQLITE_STDCALL sqlite3_value_int64(sqlite3_value *pVal){
   return sqlite3VdbeIntValue((Mem*)pVal);
 }
 SQLITE_API unsigned int SQLITE_STDCALL sqlite3_value_subtype(sqlite3_value *pVal){
-  return ((Mem*)pVal)->eSubtype;
+  Mem *pMem = (Mem*)pVal;
+  return ((pMem->flags & MEM_Subtype) ? pMem->eSubtype : 0);
 }
 SQLITE_API const unsigned char *SQLITE_STDCALL sqlite3_value_text(sqlite3_value *pVal){
   return (const unsigned char *)sqlite3ValueText(pVal, SQLITE_UTF8);
@@ -72141,8 +72633,10 @@ SQLITE_API void SQLITE_STDCALL sqlite3_result_null(sqlite3_context *pCtx){
   sqlite3VdbeMemSetNull(pCtx->pOut);
 }
 SQLITE_API void SQLITE_STDCALL sqlite3_result_subtype(sqlite3_context *pCtx, unsigned int eSubtype){
-  assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
-  pCtx->pOut->eSubtype = eSubtype & 0xff;
+  Mem *pOut = pCtx->pOut;
+  assert( sqlite3_mutex_held(pOut->db->mutex) );
+  pOut->eSubtype = eSubtype & 0xff;
+  pOut->flags |= MEM_Subtype;
 }
 SQLITE_API void SQLITE_STDCALL sqlite3_result_text(
   sqlite3_context *pCtx, 
@@ -72242,7 +72736,7 @@ SQLITE_API void SQLITE_STDCALL sqlite3_result_error_nomem(sqlite3_context *pCtx)
   sqlite3VdbeMemSetNull(pCtx->pOut);
   pCtx->isError = SQLITE_NOMEM;
   pCtx->fErrorOrAux = 1;
-  pCtx->pOut->db->mallocFailed = 1;
+  sqlite3OomFault(pCtx->pOut->db);
 }
 
 /*
@@ -72551,7 +73045,7 @@ static SQLITE_NOINLINE void *createAggContext(sqlite3_context *p, int nByte){
 ** same context that was returned on prior calls.
 */
 SQLITE_API void *SQLITE_STDCALL sqlite3_aggregate_context(sqlite3_context *p, int nByte){
-  assert( p && p->pFunc && p->pFunc->xStep );
+  assert( p && p->pFunc && p->pFunc->xFinalize );
   assert( sqlite3_mutex_held(p->pOut->db->mutex) );
   testcase( nByte<0 );
   if( (p->pMem->flags & MEM_Agg)==0 ){
@@ -72642,7 +73136,7 @@ failed:
 ** context.
 */
 SQLITE_API int SQLITE_STDCALL sqlite3_aggregate_count(sqlite3_context *p){
-  assert( p && p->pMem && p->pFunc && p->pFunc->xStep );
+  assert( p && p->pMem && p->pFunc && p->pFunc->xFinalize );
   return p->pMem->n;
 }
 #endif
@@ -72870,7 +73364,7 @@ static const void *columnName(
     ** is the case, clear the mallocFailed flag and return NULL.
     */
     if( db->mallocFailed ){
-      db->mallocFailed = 0;
+      sqlite3OomClear(db);
       ret = 0;
     }
     sqlite3_mutex_leave(db->mutex);
@@ -73571,9 +74065,9 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql(
       if( pVar->flags & MEM_Null ){
         sqlite3StrAccumAppend(&out, "NULL", 4);
       }else if( pVar->flags & MEM_Int ){
-        sqlite3XPrintf(&out, 0, "%lld", pVar->u.i);
+        sqlite3XPrintf(&out, "%lld", pVar->u.i);
       }else if( pVar->flags & MEM_Real ){
-        sqlite3XPrintf(&out, 0, "%!.15g", pVar->u.r);
+        sqlite3XPrintf(&out, "%!.15g", pVar->u.r);
       }else if( pVar->flags & MEM_Str ){
         int nOut;  /* Number of bytes of the string text to include in output */
 #ifndef SQLITE_OMIT_UTF16
@@ -73594,17 +74088,17 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql(
           while( nOut<pVar->n && (pVar->z[nOut]&0xc0)==0x80 ){ nOut++; }
         }
 #endif    
-        sqlite3XPrintf(&out, 0, "'%.*q'", nOut, pVar->z);
+        sqlite3XPrintf(&out, "'%.*q'", nOut, pVar->z);
 #ifdef SQLITE_TRACE_SIZE_LIMIT
         if( nOut<pVar->n ){
-          sqlite3XPrintf(&out, 0, "/*+%d bytes*/", pVar->n-nOut);
+          sqlite3XPrintf(&out, "/*+%d bytes*/", pVar->n-nOut);
         }
 #endif
 #ifndef SQLITE_OMIT_UTF16
         if( enc!=SQLITE_UTF8 ) sqlite3VdbeMemRelease(&utf8);
 #endif
       }else if( pVar->flags & MEM_Zero ){
-        sqlite3XPrintf(&out, 0, "zeroblob(%d)", pVar->u.nZero);
+        sqlite3XPrintf(&out, "zeroblob(%d)", pVar->u.nZero);
       }else{
         int nOut;  /* Number of bytes of the blob to include in output */
         assert( pVar->flags & MEM_Blob );
@@ -73614,12 +74108,12 @@ SQLITE_PRIVATE char *sqlite3VdbeExpandSql(
         if( nOut>SQLITE_TRACE_SIZE_LIMIT ) nOut = SQLITE_TRACE_SIZE_LIMIT;
 #endif
         for(i=0; i<nOut; i++){
-          sqlite3XPrintf(&out, 0, "%02x", pVar->z[i]&0xff);
+          sqlite3XPrintf(&out, "%02x", pVar->z[i]&0xff);
         }
         sqlite3StrAccumAppend(&out, "'", 1);
 #ifdef SQLITE_TRACE_SIZE_LIMIT
         if( nOut<pVar->n ){
-          sqlite3XPrintf(&out, 0, "/*+%d bytes*/", pVar->n-nOut);
+          sqlite3XPrintf(&out, "/*+%d bytes*/", pVar->n-nOut);
         }
 #endif
       }
@@ -74105,6 +74599,7 @@ static void memTracePrint(Mem *p){
     sqlite3VdbeMemPrettyPrint(p, zBuf);
     printf(" %s", zBuf);
   }
+  if( p->flags & MEM_Subtype ) printf(" subtype=0x%02x", p->eSubtype);
 }
 static void registerTrace(int iReg, Mem *p){
   printf("REG[%d] = ", iReg);
@@ -74274,6 +74769,9 @@ SQLITE_PRIVATE int sqlite3VdbeExec(
   Op *pOp = aOp;             /* Current operation */
 #if defined(SQLITE_DEBUG) || defined(VDBE_PROFILE)
   Op *pOrigOp;               /* Value of pOp at the top of the loop */
+#endif
+#ifdef SQLITE_DEBUG
+  int nExtraDelete = 0;      /* Verifies FORDELETE and AUXDELETE flags */
 #endif
   int rc = SQLITE_OK;        /* Value to return */
   sqlite3 *db = p->db;       /* The database */
@@ -74348,7 +74846,6 @@ SQLITE_PRIVATE int sqlite3VdbeExec(
 #endif
   for(pOp=&aOp[p->pc]; rc==SQLITE_OK; pOp++){
     assert( pOp>=aOp && pOp<&aOp[p->nOp]);
-    if( db->mallocFailed ) goto no_mem;
 #ifdef VDBE_PROFILE
     start = sqlite3Hwtime();
 #endif
@@ -75346,7 +75843,7 @@ case OP_Function0: {
   assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
   assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem-p->nCursor)+1) );
   assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
-  pCtx = sqlite3DbMallocRaw(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*));
+  pCtx = sqlite3DbMallocRawNN(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*));
   if( pCtx==0 ) goto no_mem;
   pCtx->pOut = 0;
   pCtx->pFunc = pOp->p4.pFunc;
@@ -75385,8 +75882,8 @@ case OP_Function: {
   MemSetTypeFlag(pCtx->pOut, MEM_Null);
   pCtx->fErrorOrAux = 0;
   db->lastRowid = lastRowid;
-  (*pCtx->pFunc->xFunc)(pCtx, pCtx->argc, pCtx->argv); /* IMP: R-24505-23230 */
-  lastRowid = db->lastRowid;  /* Remember rowid changes made by xFunc */
+  (*pCtx->pFunc->xSFunc)(pCtx, pCtx->argc, pCtx->argv);/* IMP: R-24505-23230 */
+  lastRowid = db->lastRowid;  /* Remember rowid changes made by xSFunc */
 
   /* If the function returned an error, throw an exception */
   if( pCtx->fErrorOrAux ){
@@ -75790,11 +76287,14 @@ case OP_Ge: {             /* same as TK_GE, jump, in1, in3 */
 ** The permutation is only valid until the next OP_Compare that has
 ** the OPFLAG_PERMUTE bit set in P5. Typically the OP_Permutation should 
 ** occur immediately prior to the OP_Compare.
+**
+** The first integer in the P4 integer array is the length of the array
+** and does not become part of the permutation.
 */
 case OP_Permutation: {
   assert( pOp->p4type==P4_INTARRAY );
   assert( pOp->p4.ai );
-  aPermute = pOp->p4.ai;
+  aPermute = pOp->p4.ai + 1;
   break;
 }
 
@@ -76097,15 +76597,18 @@ case OP_Column: {
   u64 offset64;      /* 64-bit offset */
   u32 avail;         /* Number of bytes of available data */
   u32 t;             /* A type code from the record header */
-  u16 fx;            /* pDest->flags value */
   Mem *pReg;         /* PseudoTable input register */
 
+  pC = p->apCsr[pOp->p1];
   p2 = pOp->p2;
+
+  /* If the cursor cache is stale, bring it up-to-date */
+  rc = sqlite3VdbeCursorMoveto(&pC, &p2);
+
   assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
   pDest = &aMem[pOp->p3];
   memAboutToChange(p, pDest);
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
-  pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   assert( p2<pC->nField );
   aOffset = pC->aOffset;
@@ -76114,8 +76617,6 @@ case OP_Column: {
   assert( pC->eCurType!=CURTYPE_SORTER );
   pCrsr = pC->uc.pCursor;
 
-  /* If the cursor cache is stale, bring it up-to-date */
-  rc = sqlite3VdbeCursorMoveto(pC);
   if( rc ) goto abort_due_to_error;
   if( pC->cacheStatus!=p->cacheCtr ){
     if( pC->nullRow ){
@@ -76275,10 +76776,31 @@ case OP_Column: {
   assert( sqlite3VdbeCheckMemInvariants(pDest) );
   if( VdbeMemDynamic(pDest) ) sqlite3VdbeMemSetNull(pDest);
   assert( t==pC->aType[p2] );
+  pDest->enc = encoding;
   if( pC->szRow>=aOffset[p2+1] ){
     /* This is the common case where the desired content fits on the original
     ** page - where the content is not on an overflow page */
-    sqlite3VdbeSerialGet(pC->aRow+aOffset[p2], t, pDest);
+    zData = pC->aRow + aOffset[p2];
+    if( t<12 ){
+      sqlite3VdbeSerialGet(zData, t, pDest);
+    }else{
+      /* If the column value is a string, we need a persistent value, not
+      ** a MEM_Ephem value.  This branch is a fast short-cut that is equivalent
+      ** to calling sqlite3VdbeSerialGet() and sqlite3VdbeDeephemeralize().
+      */
+      static const u16 aFlag[] = { MEM_Blob, MEM_Str|MEM_Term };
+      pDest->n = len = (t-12)/2;
+      if( pDest->szMalloc < len+2 ){
+        pDest->flags = MEM_Null;
+        if( sqlite3VdbeMemGrow(pDest, len+2, 0) ) goto no_mem;
+      }else{
+        pDest->z = pDest->zMalloc;
+      }
+      memcpy(pDest->z, zData, len);
+      pDest->z[len] = 0;
+      pDest->z[len+1] = 0;
+      pDest->flags = aFlag[t&1];
+    }
   }else{
     /* This branch happens only when content is on overflow pages */
     if( ((pOp->p5 & (OPFLAG_LENGTHARG|OPFLAG_TYPEOFARG))!=0
@@ -76290,38 +76812,20 @@ case OP_Column: {
       **    2. the length(X) function if X is a blob, and
       **    3. if the content length is zero.
       ** So we might as well use bogus content rather than reading
-      ** content from disk.  NULL will work for the value for strings
-      ** and blobs and whatever is in the payloadSize64 variable
-      ** will work for everything else. */
-      sqlite3VdbeSerialGet(t<=13 ? (u8*)&payloadSize64 : 0, t, pDest);
+      ** content from disk. */
+      static u8 aZero[8];  /* This is the bogus content */
+      sqlite3VdbeSerialGet(aZero, t, pDest);
     }else{
       rc = sqlite3VdbeMemFromBtree(pCrsr, aOffset[p2], len, !pC->isTable,
                                    pDest);
-      if( rc!=SQLITE_OK ){
-        goto op_column_error;
+      if( rc==SQLITE_OK ){
+        sqlite3VdbeSerialGet((const u8*)pDest->z, t, pDest);
+        pDest->flags &= ~MEM_Ephem;
       }
-      sqlite3VdbeSerialGet((const u8*)pDest->z, t, pDest);
-      pDest->flags &= ~MEM_Ephem;
     }
   }
-  pDest->enc = encoding;
 
 op_column_out:
-  /* If the column value is an ephemeral string, go ahead and persist
-  ** that string in case the cursor moves before the column value is
-  ** used.  The following code does the equivalent of Deephemeralize()
-  ** but does it faster. */
-  if( (pDest->flags & MEM_Ephem)!=0 && pDest->z ){
-    fx = pDest->flags & (MEM_Str|MEM_Blob);
-    assert( fx!=0 );
-    zData = (const u8*)pDest->z;
-    len = pDest->n;
-    if( sqlite3VdbeMemClearAndResize(pDest, len+2) ) goto no_mem;
-    memcpy(pDest->z, zData, len);
-    pDest->z[len] = 0;
-    pDest->z[len+1] = 0;
-    pDest->flags = fx|MEM_Term;
-  }
 op_column_error:
   UPDATE_MAX_BLOBSIZE(pDest);
   REGISTER_TRACE(pOp->p3, pDest);
@@ -76583,7 +77087,7 @@ case OP_Savepoint: {
 #endif
 
       /* Create a new savepoint structure. */
-      pNew = sqlite3DbMallocRaw(db, sizeof(Savepoint)+nName+1);
+      pNew = sqlite3DbMallocRawNN(db, sizeof(Savepoint)+nName+1);
       if( pNew ){
         pNew->zName = (char *)&pNew[1];
         memcpy(pNew->zName, zName, nName+1);
@@ -76720,28 +77224,27 @@ case OP_Savepoint: {
 case OP_AutoCommit: {
   int desiredAutoCommit;
   int iRollback;
-  int turnOnAC;
 
   desiredAutoCommit = pOp->p1;
   iRollback = pOp->p2;
-  turnOnAC = desiredAutoCommit && !db->autoCommit;
   assert( desiredAutoCommit==1 || desiredAutoCommit==0 );
   assert( desiredAutoCommit==1 || iRollback==0 );
   assert( db->nVdbeActive>0 );  /* At least this one VM is active */
   assert( p->bIsReader );
 
-  if( turnOnAC && !iRollback && db->nVdbeWrite>0 ){
-    /* If this instruction implements a COMMIT and other VMs are writing
-    ** return an error indicating that the other VMs must complete first. 
-    */
-    sqlite3VdbeError(p, "cannot commit transaction - "
-                        "SQL statements in progress");
-    rc = SQLITE_BUSY;
-  }else if( desiredAutoCommit!=db->autoCommit ){
+  if( desiredAutoCommit!=db->autoCommit ){
     if( iRollback ){
       assert( desiredAutoCommit==1 );
       sqlite3RollbackAll(db, SQLITE_ABORT_ROLLBACK);
       db->autoCommit = 1;
+    }else if( desiredAutoCommit && db->nVdbeWrite>0 ){
+      /* If this instruction implements a COMMIT and other VMs are writing
+      ** return an error indicating that the other VMs must complete first. 
+      */
+      sqlite3VdbeError(p, "cannot commit transaction - "
+                          "SQL statements in progress");
+      rc = SQLITE_BUSY;
+      break;
     }else if( (rc = sqlite3VdbeCheckFk(p, 1))!=SQLITE_OK ){
       goto vdbe_return;
     }else{
@@ -76926,15 +77429,15 @@ case OP_ReadCookie: {               /* out2 */
 
 /* Opcode: SetCookie P1 P2 P3 * *
 **
-** Write the content of register P3 (interpreted as an integer)
-** into cookie number P2 of database P1.  P2==1 is the schema version.  
-** P2==2 is the database format. P2==3 is the recommended pager cache 
+** Write the integer value P3 into cookie number P2 of database P1.
+** P2==1 is the schema version.  P2==2 is the database format.
+** P2==3 is the recommended pager cache 
 ** size, and so forth.  P1==0 is the main database file and P1==1 is the 
 ** database file used to store temporary tables.
 **
 ** A transaction must be started before executing this opcode.
 */
-case OP_SetCookie: {       /* in3 */
+case OP_SetCookie: {
   Db *pDb;
   assert( pOp->p2<SQLITE_N_BTREE_META );
   assert( pOp->p1>=0 && pOp->p1<db->nDb );
@@ -76943,17 +77446,15 @@ case OP_SetCookie: {       /* in3 */
   pDb = &db->aDb[pOp->p1];
   assert( pDb->pBt!=0 );
   assert( sqlite3SchemaMutexHeld(db, pOp->p1, 0) );
-  pIn3 = &aMem[pOp->p3];
-  sqlite3VdbeMemIntegerify(pIn3);
   /* See note about index shifting on OP_ReadCookie */
-  rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, (int)pIn3->u.i);
+  rc = sqlite3BtreeUpdateMeta(pDb->pBt, pOp->p2, pOp->p3);
   if( pOp->p2==BTREE_SCHEMA_VERSION ){
     /* When the schema cookie changes, record the new cookie internally */
-    pDb->pSchema->schema_cookie = (int)pIn3->u.i;
+    pDb->pSchema->schema_cookie = pOp->p3;
     db->flags |= SQLITE_InternChanges;
   }else if( pOp->p2==BTREE_FILE_FORMAT ){
     /* Record changes in the file format */
-    pDb->pSchema->file_format = (u8)pIn3->u.i;
+    pDb->pSchema->file_format = pOp->p3;
   }
   if( pOp->p1==1 ){
     /* Invalidate all prepared statements whenever the TEMP database
@@ -77113,6 +77614,9 @@ case OP_OpenWrite:
   pCur->nullRow = 1;
   pCur->isOrdered = 1;
   pCur->pgnoRoot = p2;
+#ifdef SQLITE_DEBUG
+  pCur->wrFlag = wrFlag;
+#endif
   rc = sqlite3BtreeCursor(pX, p2, wrFlag, pKeyInfo, pCur->uc.pCursor);
   pCur->pKeyInfo = pKeyInfo;
   /* Set the VdbeCursor.isTable variable. Previous versions of
@@ -77566,32 +78070,6 @@ seek_not_found:
   }
   break;
 }
-
-/* Opcode: Seek P1 P2 * * *
-** Synopsis:  intkey=r[P2]
-**
-** P1 is an open table cursor and P2 is a rowid integer.  Arrange
-** for P1 to move so that it points to the rowid given by P2.
-**
-** This is actually a deferred seek.  Nothing actually happens until
-** the cursor is used to read a record.  That way, if no reads
-** occur, no unnecessary I/O happens.
-*/
-case OP_Seek: {    /* in2 */
-  VdbeCursor *pC;
-
-  assert( pOp->p1>=0 && pOp->p1<p->nCursor );
-  pC = p->apCsr[pOp->p1];
-  assert( pC!=0 );
-  assert( pC->eCurType==CURTYPE_BTREE );
-  assert( pC->uc.pCursor!=0 );
-  assert( pC->isTable );
-  pC->nullRow = 0;
-  pIn2 = &aMem[pOp->p2];
-  pC->movetoTarget = sqlite3VdbeIntValue(pIn2);
-  pC->deferredMoveto = 1;
-  break;
-}
   
 
 /* Opcode: Found P1 P2 P3 P4 *
@@ -78062,14 +78540,22 @@ case OP_InsertInt: {
 **
 ** Delete the record at which the P1 cursor is currently pointing.
 **
-** If the P5 parameter is non-zero, the cursor will be left pointing at 
-** either the next or the previous record in the table. If it is left 
-** pointing at the next record, then the next Next instruction will be a 
-** no-op. As a result, in this case it is OK to delete a record from within a
-** Next loop. If P5 is zero, then the cursor is left in an undefined state.
+** If the OPFLAG_SAVEPOSITION bit of the P5 parameter is set, then
+** the cursor will be left pointing at  either the next or the previous
+** record in the table. If it is left pointing at the next record, then
+** the next Next instruction will be a no-op. As a result, in this case
+** it is ok to delete a record from within a Next loop. If 
+** OPFLAG_SAVEPOSITION bit of P5 is clear, then the cursor will be
+** left in an undefined state.
 **
-** If the OPFLAG_NCHANGE flag of P2 is set, then the row change count is
-** incremented (otherwise not).
+** If the OPFLAG_AUXDELETE bit is set on P5, that indicates that this
+** delete one of several associated with deleting a table row and all its
+** associated index entries.  Exactly one of those deletes is the "primary"
+** delete.  The others are all on OPFLAG_FORDELETE cursors or else are
+** marked with the AUXDELETE flag.
+**
+** If the OPFLAG_NCHANGE flag of P2 (NB: P2 not P5) is set, then the row
+** change count is incremented (otherwise not).
 **
 ** P1 must not be pseudo-table.  It has to be a real table with
 ** multiple rows.
@@ -78105,7 +78591,26 @@ case OP_Delete: {
     assert( pC->movetoTarget==iKey ); 
   }
 #endif
- 
+
+  /* Only flags that can be set are SAVEPOISTION and AUXDELETE */ 
+  assert( (pOp->p5 & ~(OPFLAG_SAVEPOSITION|OPFLAG_AUXDELETE))==0 );
+  assert( OPFLAG_SAVEPOSITION==BTREE_SAVEPOSITION );
+  assert( OPFLAG_AUXDELETE==BTREE_AUXDELETE );
+
+#ifdef SQLITE_DEBUG
+  if( p->pFrame==0 ){
+    if( pC->isEphemeral==0
+        && (pOp->p5 & OPFLAG_AUXDELETE)==0
+        && (pC->wrFlag & OPFLAG_FORDELETE)==0
+      ){
+      nExtraDelete++;
+    }
+    if( pOp->p2 & OPFLAG_NCHANGE ){
+      nExtraDelete--;
+    }
+  }
+#endif
+
   rc = sqlite3BtreeDelete(pC->uc.pCursor, pOp->p5);
   pC->cacheStatus = CACHE_STALE;
 
@@ -78650,18 +79155,34 @@ case OP_IdxDelete: {
   r.nField = (u16)pOp->p3;
   r.default_rc = 0;
   r.aMem = &aMem[pOp->p2];
-#ifdef SQLITE_DEBUG
-  { int i; for(i=0; i<r.nField; i++) assert( memIsValid(&r.aMem[i]) ); }
-#endif
   rc = sqlite3BtreeMovetoUnpacked(pCrsr, &r, 0, 0, &res);
   if( rc==SQLITE_OK && res==0 ){
-    rc = sqlite3BtreeDelete(pCrsr, 0);
+    rc = sqlite3BtreeDelete(pCrsr, BTREE_AUXDELETE);
   }
   assert( pC->deferredMoveto==0 );
   pC->cacheStatus = CACHE_STALE;
   break;
 }
 
+/* Opcode: Seek P1 * P3 P4 *
+** Synopsis:  Move P3 to P1.rowid
+**
+** P1 is an open index cursor and P3 is a cursor on the corresponding
+** table.  This opcode does a deferred seek of the P3 table cursor
+** to the row that corresponds to the current row of P1.
+**
+** This is a deferred seek.  Nothing actually happens until
+** the cursor is used to read a record.  That way, if no reads
+** occur, no unnecessary I/O happens.
+**
+** P4 may be an array of integers (type P4_INTARRAY) containing
+** one entry for each column in the P3 table.  If array entry a(i)
+** is non-zero, then reading column a(i)-1 from cursor P3 is 
+** equivalent to performing the deferred seek and then reading column i 
+** from P1.  This information is stored in P3 and used to redirect
+** reads against P3 over to P1, thus possibly avoiding the need to
+** seek and read cursor P3.
+*/
 /* Opcode: IdxRowid P1 P2 * * *
 ** Synopsis: r[P2]=rowid
 **
@@ -78671,37 +79192,57 @@ case OP_IdxDelete: {
 **
 ** See also: Rowid, MakeRecord.
 */
+case OP_Seek:
 case OP_IdxRowid: {              /* out2 */
-  BtCursor *pCrsr;
-  VdbeCursor *pC;
-  i64 rowid;
+  VdbeCursor *pC;                /* The P1 index cursor */
+  VdbeCursor *pTabCur;           /* The P2 table cursor (OP_Seek only) */
+  i64 rowid;                     /* Rowid that P1 current points to */
 
-  pOut = out2Prerelease(p, pOp);
   assert( pOp->p1>=0 && pOp->p1<p->nCursor );
   pC = p->apCsr[pOp->p1];
   assert( pC!=0 );
   assert( pC->eCurType==CURTYPE_BTREE );
-  pCrsr = pC->uc.pCursor;
-  assert( pCrsr!=0 );
-  pOut->flags = MEM_Null;
+  assert( pC->uc.pCursor!=0 );
   assert( pC->isTable==0 );
   assert( pC->deferredMoveto==0 );
+  assert( !pC->nullRow || pOp->opcode==OP_IdxRowid );
+
+  /* The IdxRowid and Seek opcodes are combined because of the commonality
+  ** of sqlite3VdbeCursorRestore() and sqlite3VdbeIdxRowid(). */
+  rc = sqlite3VdbeCursorRestore(pC);
 
   /* sqlite3VbeCursorRestore() can only fail if the record has been deleted
-  ** out from under the cursor.  That will never happend for an IdxRowid
-  ** opcode, hence the NEVER() arround the check of the return value.
-  */
-  rc = sqlite3VdbeCursorRestore(pC);
+  ** out from under the cursor.  That will never happens for an IdxRowid
+  ** or Seek opcode */
   if( NEVER(rc!=SQLITE_OK) ) goto abort_due_to_error;
 
   if( !pC->nullRow ){
     rowid = 0;  /* Not needed.  Only used to silence a warning. */
-    rc = sqlite3VdbeIdxRowid(db, pCrsr, &rowid);
+    rc = sqlite3VdbeIdxRowid(db, pC->uc.pCursor, &rowid);
     if( rc!=SQLITE_OK ){
       goto abort_due_to_error;
     }
-    pOut->u.i = rowid;
-    pOut->flags = MEM_Int;
+    if( pOp->opcode==OP_Seek ){
+      assert( pOp->p3>=0 && pOp->p3<p->nCursor );
+      pTabCur = p->apCsr[pOp->p3];
+      assert( pTabCur!=0 );
+      assert( pTabCur->eCurType==CURTYPE_BTREE );
+      assert( pTabCur->uc.pCursor!=0 );
+      assert( pTabCur->isTable );
+      pTabCur->nullRow = 0;
+      pTabCur->movetoTarget = rowid;
+      pTabCur->deferredMoveto = 1;
+      assert( pOp->p4type==P4_INTARRAY || pOp->p4.ai==0 );
+      pTabCur->aAltMap = pOp->p4.ai;
+      pTabCur->pAltCursor = pC;
+    }else{
+      pOut = out2Prerelease(p, pOp);
+      pOut->u.i = rowid;
+      pOut->flags = MEM_Int;
+    }
+  }else{
+    assert( pOp->opcode==OP_IdxRowid );
+    sqlite3VdbeMemSetNull(&aMem[pOp->p2]);
   }
   break;
 }
@@ -78820,6 +79361,7 @@ case OP_Destroy: {     /* out2 */
   int iDb;
 
   assert( p->readOnly==0 );
+  assert( pOp->p1>1 );
   pOut = out2Prerelease(p, pOp);
   pOut->flags = MEM_Null;
   if( db->nVdbeRead > db->nVDestroy+1 ){
@@ -79095,7 +79637,7 @@ case OP_IntegrityCk: {
   assert( p->bIsReader );
   nRoot = pOp->p2;
   assert( nRoot>0 );
-  aRoot = sqlite3DbMallocRaw(db, sizeof(int)*(nRoot+1) );
+  aRoot = sqlite3DbMallocRawNN(db, sizeof(int)*(nRoot+1) );
   if( aRoot==0 ) goto no_mem;
   assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
   pnErr = &aMem[pOp->p3];
@@ -79477,20 +80019,31 @@ case OP_IfPos: {        /* jump, in1 */
   break;
 }
 
-/* Opcode: SetIfNotPos P1 P2 P3 * *
-** Synopsis: if r[P1]<=0 then r[P2]=P3
+/* Opcode: OffsetLimit P1 P2 P3 * *
+** Synopsis: if r[P1]>0 then r[P2]=r[P1]+max(0,r[P3]) else r[P2]=(-1)
 **
-** Register P1 must contain an integer.
-** If the value of register P1 is not positive (if it is less than 1) then
-** set the value of register P2 to be the integer P3.
+** This opcode performs a commonly used computation associated with
+** LIMIT and OFFSET process.  r[P1] holds the limit counter.  r[P3]
+** holds the offset counter.  The opcode computes the combined value
+** of the LIMIT and OFFSET and stores that value in r[P2].  The r[P2]
+** value computed is the total number of rows that will need to be
+** visited in order to complete the query.
+**
+** If r[P3] is zero or negative, that means there is no OFFSET
+** and r[P2] is set to be the value of the LIMIT, r[P1].
+**
+** if r[P1] is zero or negative, that means there is no LIMIT
+** and r[P2] is set to -1. 
+**
+** Otherwise, r[P2] is set to the sum of r[P1] and r[P3].
 */
-case OP_SetIfNotPos: {        /* in1, in2 */
+case OP_OffsetLimit: {    /* in1, out2, in3 */
   pIn1 = &aMem[pOp->p1];
-  assert( pIn1->flags&MEM_Int );
-  if( pIn1->u.i<=0 ){
-    pOut = out2Prerelease(p, pOp);
-    pOut->u.i = pOp->p3;
-  }
+  pIn3 = &aMem[pOp->p3];
+  pOut = out2Prerelease(p, pOp);
+  assert( pIn1->flags & MEM_Int );
+  assert( pIn3->flags & MEM_Int );
+  pOut->u.i = pIn1->u.i<=0 ? -1 : pIn1->u.i+(pIn3->u.i>0?pIn3->u.i:0);
   break;
 }
 
@@ -79581,7 +80134,7 @@ case OP_AggStep0: {
   assert( pOp->p3>0 && pOp->p3<=(p->nMem-p->nCursor) );
   assert( n==0 || (pOp->p2>0 && pOp->p2+n<=(p->nMem-p->nCursor)+1) );
   assert( pOp->p3<pOp->p2 || pOp->p3>=pOp->p2+n );
-  pCtx = sqlite3DbMallocRaw(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*));
+  pCtx = sqlite3DbMallocRawNN(db, sizeof(*pCtx) + (n-1)*sizeof(sqlite3_value*));
   if( pCtx==0 ) goto no_mem;
   pCtx->pMem = 0;
   pCtx->pFunc = pOp->p4.pFunc;
@@ -79624,7 +80177,7 @@ case OP_AggStep: {
   pCtx->pOut = &t;
   pCtx->fErrorOrAux = 0;
   pCtx->skipFlag = 0;
-  (pCtx->pFunc->xStep)(pCtx,pCtx->argc,pCtx->argv); /* IMP: R-24505-23230 */
+  (pCtx->pFunc->xSFunc)(pCtx,pCtx->argc,pCtx->argv); /* IMP: R-24505-23230 */
   if( pCtx->fErrorOrAux ){
     if( pCtx->isError ){
       sqlite3VdbeError(p, "%s", sqlite3_value_text(&t));
@@ -80448,7 +81001,7 @@ vdbe_error_halt:
   sqlite3_log(rc, "statement aborts at %d: [%s] %s", 
                    (int)(pOp - aOp), p->zSql, p->zErrMsg);
   sqlite3VdbeHalt(p);
-  if( rc==SQLITE_IOERR_NOMEM ) db->mallocFailed = 1;
+  if( rc==SQLITE_IOERR_NOMEM ) sqlite3OomFault(db);
   rc = SQLITE_ERROR;
   if( resetSchemaOnFault>0 ){
     sqlite3ResetOneSchema(db, resetSchemaOnFault-1);
@@ -80462,6 +81015,9 @@ vdbe_return:
   testcase( nVmStep>0 );
   p->aCounter[SQLITE_STMTSTATUS_VM_STEP] += (int)nVmStep;
   sqlite3VdbeLeave(p);
+  assert( rc!=SQLITE_OK || nExtraDelete==0 
+       || sqlite3_strlike("DELETE%",p->zSql,0)!=0 
+  );
   return rc;
 
   /* Jump to here if a string or blob larger than SQLITE_MAX_LENGTH
@@ -80475,7 +81031,7 @@ too_big:
   /* Jump to here if a malloc() fails.
   */
 no_mem:
-  db->mallocFailed = 1;
+  sqlite3OomFault(db);
   sqlite3VdbeError(p, "out of memory");
   rc = SQLITE_NOMEM;
   goto vdbe_error_halt;
@@ -80496,7 +81052,7 @@ abort_due_to_error:
   */
 abort_due_to_interrupt:
   assert( db->u1.isInterrupted );
-  rc = SQLITE_INTERRUPT;
+  rc = db->mallocFailed ? SQLITE_NOMEM : SQLITE_INTERRUPT;
   p->rc = rc;
   sqlite3VdbeError(p, "%s", sqlite3ErrStr(rc));
   goto vdbe_error_halt;
@@ -80622,38 +81178,6 @@ SQLITE_API int SQLITE_STDCALL sqlite3_blob_open(
 ){
   int nAttempt = 0;
   int iCol;               /* Index of zColumn in row-record */
-
-  /* This VDBE program seeks a btree cursor to the identified 
-  ** db/table/row entry. The reason for using a vdbe program instead
-  ** of writing code to use the b-tree layer directly is that the
-  ** vdbe program will take advantage of the various transaction,
-  ** locking and error handling infrastructure built into the vdbe.
-  **
-  ** After seeking the cursor, the vdbe executes an OP_ResultRow.
-  ** Code external to the Vdbe then "borrows" the b-tree cursor and
-  ** uses it to implement the blob_read(), blob_write() and 
-  ** blob_bytes() functions.
-  **
-  ** The sqlite3_blob_close() function finalizes the vdbe program,
-  ** which closes the b-tree cursor and (possibly) commits the 
-  ** transaction.
-  */
-  static const int iLn = VDBE_OFFSET_LINENO(4);
-  static const VdbeOpList openBlob[] = {
-    /* {OP_Transaction, 0, 0, 0},  // 0: Inserted separately */
-    {OP_TableLock, 0, 0, 0},       /* 1: Acquire a read or write lock */
-    /* One of the following two instructions is replaced by an OP_Noop. */
-    {OP_OpenRead, 0, 0, 0},        /* 2: Open cursor 0 for reading */
-    {OP_OpenWrite, 0, 0, 0},       /* 3: Open cursor 0 for read/write */
-    {OP_Variable, 1, 1, 1},        /* 4: Push the rowid to the stack */
-    {OP_NotExists, 0, 10, 1},      /* 5: Seek the cursor */
-    {OP_Column, 0, 0, 1},          /* 6  */
-    {OP_ResultRow, 1, 0, 0},       /* 7  */
-    {OP_Goto, 0, 4, 0},            /* 8  */
-    {OP_Close, 0, 0, 0},           /* 9  */
-    {OP_Halt, 0, 0, 0},            /* 10 */
-  };
-
   int rc = SQLITE_OK;
   char *zErr = 0;
   Table *pTab;
@@ -80772,45 +81296,78 @@ SQLITE_API int SQLITE_STDCALL sqlite3_blob_open(
     pBlob->pStmt = (sqlite3_stmt *)sqlite3VdbeCreate(pParse);
     assert( pBlob->pStmt || db->mallocFailed );
     if( pBlob->pStmt ){
+      
+      /* This VDBE program seeks a btree cursor to the identified 
+      ** db/table/row entry. The reason for using a vdbe program instead
+      ** of writing code to use the b-tree layer directly is that the
+      ** vdbe program will take advantage of the various transaction,
+      ** locking and error handling infrastructure built into the vdbe.
+      **
+      ** After seeking the cursor, the vdbe executes an OP_ResultRow.
+      ** Code external to the Vdbe then "borrows" the b-tree cursor and
+      ** uses it to implement the blob_read(), blob_write() and 
+      ** blob_bytes() functions.
+      **
+      ** The sqlite3_blob_close() function finalizes the vdbe program,
+      ** which closes the b-tree cursor and (possibly) commits the 
+      ** transaction.
+      */
+      static const int iLn = VDBE_OFFSET_LINENO(2);
+      static const VdbeOpList openBlob[] = {
+        {OP_TableLock,      0, 0, 0},  /* 0: Acquire a read or write lock */
+        {OP_OpenRead,       0, 0, 0},  /* 1: Open a cursor */
+        {OP_Variable,       1, 1, 0},  /* 2: Move ?1 into reg[1] */
+        {OP_NotExists,      0, 7, 1},  /* 3: Seek the cursor */
+        {OP_Column,         0, 0, 1},  /* 4  */
+        {OP_ResultRow,      1, 0, 0},  /* 5  */
+        {OP_Goto,           0, 2, 0},  /* 6  */
+        {OP_Close,          0, 0, 0},  /* 7  */
+        {OP_Halt,           0, 0, 0},  /* 8  */
+      };
       Vdbe *v = (Vdbe *)pBlob->pStmt;
       int iDb = sqlite3SchemaToIndex(db, pTab->pSchema);
-
+      VdbeOp *aOp;
 
       sqlite3VdbeAddOp4Int(v, OP_Transaction, iDb, flags, 
                            pTab->pSchema->schema_cookie,
                            pTab->pSchema->iGeneration);
       sqlite3VdbeChangeP5(v, 1);     
-      sqlite3VdbeAddOpList(v, ArraySize(openBlob), openBlob, iLn);
+      aOp = sqlite3VdbeAddOpList(v, ArraySize(openBlob), openBlob, iLn);
 
       /* Make sure a mutex is held on the table to be accessed */
       sqlite3VdbeUsesBtree(v, iDb); 
 
-      /* Configure the OP_TableLock instruction */
+      if( db->mallocFailed==0 ){
+        assert( aOp!=0 );
+        /* Configure the OP_TableLock instruction */
 #ifdef SQLITE_OMIT_SHARED_CACHE
-      sqlite3VdbeChangeToNoop(v, 1);
+        aOp[0].opcode = OP_Noop;
 #else
-      sqlite3VdbeChangeP1(v, 1, iDb);
-      sqlite3VdbeChangeP2(v, 1, pTab->tnum);
-      sqlite3VdbeChangeP3(v, 1, flags);
-      sqlite3VdbeChangeP4(v, 1, pTab->zName, P4_TRANSIENT);
+        aOp[0].p1 = iDb;
+        aOp[0].p2 = pTab->tnum;
+        aOp[0].p3 = flags;
+        sqlite3VdbeChangeP4(v, 1, pTab->zName, P4_TRANSIENT);
+      }
+      if( db->mallocFailed==0 ){
 #endif
 
-      /* Remove either the OP_OpenWrite or OpenRead. Set the P2 
-      ** parameter of the other to pTab->tnum.  */
-      sqlite3VdbeChangeToNoop(v, 3 - flags);
-      sqlite3VdbeChangeP2(v, 2 + flags, pTab->tnum);
-      sqlite3VdbeChangeP3(v, 2 + flags, iDb);
+        /* Remove either the OP_OpenWrite or OpenRead. Set the P2 
+        ** parameter of the other to pTab->tnum.  */
+        if( flags ) aOp[1].opcode = OP_OpenWrite;
+        aOp[1].p2 = pTab->tnum;
+        aOp[1].p3 = iDb;   
+
+        /* Configure the number of columns. Configure the cursor to
+        ** think that the table has one more column than it really
+        ** does. An OP_Column to retrieve this imaginary column will
+        ** always return an SQL NULL. This is useful because it means
+        ** we can invoke OP_Column to fill in the vdbe cursors type 
+        ** and offset cache without causing any IO.
+        */
+        aOp[1].p4type = P4_INT32;
+        aOp[1].p4.i = pTab->nCol+1;
+        aOp[4].p2 = pTab->nCol;
 
-      /* Configure the number of columns. Configure the cursor to
-      ** think that the table has one more column than it really
-      ** does. An OP_Column to retrieve this imaginary column will
-      ** always return an SQL NULL. This is useful because it means
-      ** we can invoke OP_Column to fill in the vdbe cursors type 
-      ** and offset cache without causing any IO.
-      */
-      sqlite3VdbeChangeP4(v, 2+flags, SQLITE_INT_TO_PTR(pTab->nCol+1),P4_INT32);
-      sqlite3VdbeChangeP2(v, 6, pTab->nCol);
-      if( !db->mallocFailed ){
         pParse->nVar = 1;
         pParse->nMem = 1;
         pParse->nTab = 1;
@@ -81723,7 +82280,7 @@ static int vdbePmaReaderInit(
 
   rc = vdbePmaReaderSeek(pTask, pReadr, pFile, iStart);
   if( rc==SQLITE_OK ){
-    u64 nByte;                    /* Size of PMA in bytes */
+    u64 nByte = 0;                 /* Size of PMA in bytes */
     rc = vdbePmaReadVarint(pReadr, &nByte);
     pReadr->iEof = pReadr->iReadOff + nByte;
     *pnByte += nByte;
@@ -82807,6 +83364,7 @@ SQLITE_PRIVATE int sqlite3VdbeSorterWrite(
 
     if( nMin>pSorter->nMemory ){
       u8 *aNew;
+      int iListOff = (u8*)pSorter->list.pList - pSorter->list.aMemory;
       int nNew = pSorter->nMemory * 2;
       while( nNew < nMin ) nNew = nNew*2;
       if( nNew > pSorter->mxPmaSize ) nNew = pSorter->mxPmaSize;
@@ -82814,16 +83372,16 @@ SQLITE_PRIVATE int sqlite3VdbeSorterWrite(
 
       aNew = sqlite3Realloc(pSorter->list.aMemory, nNew);
       if( !aNew ) return SQLITE_NOMEM;
-      pSorter->list.pList = (SorterRecord*)(
-          aNew + ((u8*)pSorter->list.pList - pSorter->list.aMemory)
-      );
+      pSorter->list.pList = (SorterRecord*)&aNew[iListOff];
       pSorter->list.aMemory = aNew;
       pSorter->nMemory = nNew;
     }
 
     pNew = (SorterRecord*)&pSorter->list.aMemory[pSorter->iMemory];
     pSorter->iMemory += ROUND8(nReq);
-    pNew->u.iNext = (int)((u8*)(pSorter->list.pList) - pSorter->list.aMemory);
+    if( pSorter->list.pList ){
+      pNew->u.iNext = (int)((u8*)(pSorter->list.pList) - pSorter->list.aMemory);
+    }
   }else{
     pNew = (SorterRecord *)sqlite3Malloc(nReq);
     if( pNew==0 ){
@@ -84281,9 +84839,8 @@ SQLITE_PRIVATE int sqlite3MemJournalSize(void){
 ** The return value from this routine is WRC_Abort to abandon the tree walk
 ** and WRC_Continue to continue.
 */
-SQLITE_PRIVATE int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){
+static SQLITE_NOINLINE int walkExpr(Walker *pWalker, Expr *pExpr){
   int rc;
-  if( pExpr==0 ) return WRC_Continue;
   testcase( ExprHasProperty(pExpr, EP_TokenOnly) );
   testcase( ExprHasProperty(pExpr, EP_Reduced) );
   rc = pWalker->xExprCallback(pWalker, pExpr);
@@ -84299,6 +84856,9 @@ SQLITE_PRIVATE int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){
   }
   return rc & WRC_Abort;
 }
+SQLITE_PRIVATE int sqlite3WalkExpr(Walker *pWalker, Expr *pExpr){
+  return pExpr ? walkExpr(pWalker,pExpr) : WRC_Continue;
+}
 
 /*
 ** Call sqlite3WalkExpr() for every expression in list p or until
@@ -85072,7 +85632,7 @@ static int resolveExprStep(Walker *pWalker, Expr *pExpr){
           wrong_num_args = 1;
         }
       }else{
-        is_agg = pDef->xFunc==0;
+        is_agg = pDef->xFinalize!=0;
         if( pDef->funcFlags & SQLITE_FUNC_UNLIKELY ){
           ExprSetProperty(pExpr, EP_Unlikely|EP_Skip);
           if( n==2 ){
@@ -85800,10 +86360,12 @@ SQLITE_PRIVATE int sqlite3ResolveExprNames(
 #endif
   savedHasAgg = pNC->ncFlags & (NC_HasAgg|NC_MinMaxAgg);
   pNC->ncFlags &= ~(NC_HasAgg|NC_MinMaxAgg);
-  memset(&w, 0, sizeof(w));
+  w.pParse = pNC->pParse;
   w.xExprCallback = resolveExprStep;
   w.xSelectCallback = resolveSelectStep;
-  w.pParse = pNC->pParse;
+  w.xSelectCallback2 = 0;
+  w.walkerDepth = 0;
+  w.eCode = 0;
   w.u.pNC = pNC;
   sqlite3WalkExpr(&w, pExpr);
 #if SQLITE_MAX_EXPR_DEPTH>0
@@ -85989,8 +86551,7 @@ SQLITE_PRIVATE Expr *sqlite3ExprAddCollateToken(
 SQLITE_PRIVATE Expr *sqlite3ExprAddCollateString(Parse *pParse, Expr *pExpr, const char *zC){
   Token s;
   assert( zC!=0 );
-  s.z = zC;
-  s.n = sqlite3Strlen30(s.z);
+  sqlite3TokenInit(&s, (char*)zC);
   return sqlite3ExprAddCollateToken(pParse, pExpr, &s, 0);
 }
 
@@ -86358,6 +86919,7 @@ SQLITE_PRIVATE Expr *sqlite3ExprAlloc(
   int nExtra = 0;
   int iValue = 0;
 
+  assert( db!=0 );
   if( pToken ){
     if( op!=TK_INTEGER || pToken->z==0
           || sqlite3GetInt32(pToken->z, &iValue)==0 ){
@@ -86365,8 +86927,9 @@ SQLITE_PRIVATE Expr *sqlite3ExprAlloc(
       assert( iValue>=0 );
     }
   }
-  pNew = sqlite3DbMallocZero(db, sizeof(Expr)+nExtra);
+  pNew = sqlite3DbMallocRawNN(db, sizeof(Expr)+nExtra);
   if( pNew ){
+    memset(pNew, 0, sizeof(Expr));
     pNew->op = (u8)op;
     pNew->iAgg = -1;
     if( pToken ){
@@ -86603,7 +87166,10 @@ SQLITE_PRIVATE void sqlite3ExprAssignVarNumber(Parse *pParse, Expr *pExpr){
       if( x>pParse->nzVar ){
         char **a;
         a = sqlite3DbRealloc(db, pParse->azVar, x*sizeof(a[0]));
-        if( a==0 ) return;  /* Error reported through db->mallocFailed */
+        if( a==0 ){
+          assert( db->mallocFailed ); /* Error reported through mallocFailed */
+          return;
+        }
         pParse->azVar = a;
         memset(&a[pParse->nzVar], 0, (x-pParse->nzVar)*sizeof(a[0]));
         pParse->nzVar = x;
@@ -86758,6 +87324,7 @@ static int dupedExprSize(Expr *p, int flags){
 static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){
   Expr *pNew = 0;                      /* Value to return */
   assert( flags==0 || flags==EXPRDUP_REDUCE );
+  assert( db!=0 );
   if( p ){
     const int isReduced = (flags&EXPRDUP_REDUCE);
     u8 *zAlloc;
@@ -86770,7 +87337,7 @@ static Expr *exprDup(sqlite3 *db, Expr *p, int flags, u8 **pzBuffer){
       zAlloc = *pzBuffer;
       staticFlag = EP_Static;
     }else{
-      zAlloc = sqlite3DbMallocRaw(db, dupedExprSize(p, flags));
+      zAlloc = sqlite3DbMallocRawNN(db, dupedExprSize(p, flags));
     }
     pNew = (Expr *)zAlloc;
 
@@ -86893,12 +87460,13 @@ SQLITE_PRIVATE ExprList *sqlite3ExprListDup(sqlite3 *db, ExprList *p, int flags)
   ExprList *pNew;
   struct ExprList_item *pItem, *pOldItem;
   int i;
+  assert( db!=0 );
   if( p==0 ) return 0;
-  pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
+  pNew = sqlite3DbMallocRawNN(db, sizeof(*pNew) );
   if( pNew==0 ) return 0;
   pNew->nExpr = i = p->nExpr;
   if( (flags & EXPRDUP_REDUCE)==0 ) for(i=1; i<p->nExpr; i+=i){}
-  pNew->a = pItem = sqlite3DbMallocRaw(db,  i*sizeof(p->a[0]) );
+  pNew->a = pItem = sqlite3DbMallocRawNN(db,  i*sizeof(p->a[0]) );
   if( pItem==0 ){
     sqlite3DbFree(db, pNew);
     return 0;
@@ -86929,9 +87497,10 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
   SrcList *pNew;
   int i;
   int nByte;
+  assert( db!=0 );
   if( p==0 ) return 0;
   nByte = sizeof(*p) + (p->nSrc>0 ? sizeof(p->a[0]) * (p->nSrc-1) : 0);
-  pNew = sqlite3DbMallocRaw(db, nByte );
+  pNew = sqlite3DbMallocRawNN(db, nByte );
   if( pNew==0 ) return 0;
   pNew->nSrc = pNew->nAlloc = p->nSrc;
   for(i=0; i<p->nSrc; i++){
@@ -86968,11 +87537,12 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListDup(sqlite3 *db, SrcList *p, int flags){
 SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
   IdList *pNew;
   int i;
+  assert( db!=0 );
   if( p==0 ) return 0;
-  pNew = sqlite3DbMallocRaw(db, sizeof(*pNew) );
+  pNew = sqlite3DbMallocRawNN(db, sizeof(*pNew) );
   if( pNew==0 ) return 0;
   pNew->nId = p->nId;
-  pNew->a = sqlite3DbMallocRaw(db, p->nId*sizeof(p->a[0]) );
+  pNew->a = sqlite3DbMallocRawNN(db, p->nId*sizeof(p->a[0]) );
   if( pNew->a==0 ){
     sqlite3DbFree(db, pNew);
     return 0;
@@ -86990,8 +87560,9 @@ SQLITE_PRIVATE IdList *sqlite3IdListDup(sqlite3 *db, IdList *p){
 }
 SQLITE_PRIVATE Select *sqlite3SelectDup(sqlite3 *db, Select *p, int flags){
   Select *pNew, *pPrior;
+  assert( db!=0 );
   if( p==0 ) return 0;
-  pNew = sqlite3DbMallocRaw(db, sizeof(*p) );
+  pNew = sqlite3DbMallocRawNN(db, sizeof(*p) );
   if( pNew==0 ) return 0;
   pNew->pEList = sqlite3ExprListDup(db, p->pEList, flags);
   pNew->pSrc = sqlite3SrcListDup(db, p->pSrc, flags);
@@ -87037,12 +87608,14 @@ SQLITE_PRIVATE ExprList *sqlite3ExprListAppend(
   Expr *pExpr             /* Expression to be appended. Might be NULL */
 ){
   sqlite3 *db = pParse->db;
+  assert( db!=0 );
   if( pList==0 ){
-    pList = sqlite3DbMallocZero(db, sizeof(ExprList) );
+    pList = sqlite3DbMallocRawNN(db, sizeof(ExprList) );
     if( pList==0 ){
       goto no_mem;
     }
-    pList->a = sqlite3DbMallocRaw(db, sizeof(pList->a[0]));
+    pList->nExpr = 0;
+    pList->a = sqlite3DbMallocRawNN(db, sizeof(pList->a[0]));
     if( pList->a==0 ) goto no_mem;
   }else if( (pList->nExpr & (pList->nExpr-1))==0 ){
     struct ExprList_item *a;
@@ -88799,7 +89372,7 @@ SQLITE_PRIVATE int sqlite3ExprCodeTarget(Parse *pParse, Expr *pExpr, int target)
       zId = pExpr->u.zToken;
       nId = sqlite3Strlen30(zId);
       pDef = sqlite3FindFunction(db, zId, nId, nFarg, enc, 0);
-      if( pDef==0 || pDef->xFunc==0 ){
+      if( pDef==0 || pDef->xFinalize!=0 ){
         sqlite3ErrorMsg(pParse, "unknown function: %.*s()", nId, zId);
         break;
       }
@@ -90746,33 +91319,6 @@ exit_rename_table:
   db->flags = savedDbFlags;
 }
 
-
-/*
-** Generate code to make sure the file format number is at least minFormat.
-** The generated code will increase the file format number if necessary.
-*/
-SQLITE_PRIVATE void sqlite3MinimumFileFormat(Parse *pParse, int iDb, int minFormat){
-  Vdbe *v;
-  v = sqlite3GetVdbe(pParse);
-  /* The VDBE should have been allocated before this routine is called.
-  ** If that allocation failed, we would have quit before reaching this
-  ** point */
-  if( ALWAYS(v) ){
-    int r1 = sqlite3GetTempReg(pParse);
-    int r2 = sqlite3GetTempReg(pParse);
-    int addr1;
-    sqlite3VdbeAddOp3(v, OP_ReadCookie, iDb, r1, BTREE_FILE_FORMAT);
-    sqlite3VdbeUsesBtree(v, iDb);
-    sqlite3VdbeAddOp2(v, OP_Integer, minFormat, r2);
-    addr1 = sqlite3VdbeAddOp3(v, OP_Ge, r2, 0, r1);
-    sqlite3VdbeChangeP5(v, SQLITE_NOTNULL); VdbeCoverage(v);
-    sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, r2);
-    sqlite3VdbeJumpHere(v, addr1);
-    sqlite3ReleaseTempReg(pParse, r1);
-    sqlite3ReleaseTempReg(pParse, r2);
-  }
-}
-
 /*
 ** This function is called after an "ALTER TABLE ... ADD" statement
 ** has been parsed. Argument pColDef contains the text of the new
@@ -90791,9 +91337,11 @@ SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
   Column *pCol;             /* The new column */
   Expr *pDflt;              /* Default value for the new column */
   sqlite3 *db;              /* The database connection; */
+  Vdbe *v = pParse->pVdbe;  /* The prepared statement under construction */
 
   db = pParse->db;
   if( pParse->nErr || db->mallocFailed ) return;
+  assert( v!=0 );
   pNew = pParse->pNewTable;
   assert( pNew );
 
@@ -90853,7 +91401,7 @@ SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
     rc = sqlite3ValueFromExpr(db, pDflt, SQLITE_UTF8, SQLITE_AFF_BLOB, &pVal);
     assert( rc==SQLITE_OK || rc==SQLITE_NOMEM );
     if( rc!=SQLITE_OK ){
-      db->mallocFailed = 1;
+      assert( db->mallocFailed == 1 );
       return;
     }
     if( !pVal ){
@@ -90883,11 +91431,16 @@ SQLITE_PRIVATE void sqlite3AlterFinishAddColumn(Parse *pParse, Token *pColDef){
     db->flags = savedDbFlags;
   }
 
-  /* If the default value of the new column is NULL, then set the file
+  /* If the default value of the new column is NULL, then the file
   ** format to 2. If the default value of the new column is not NULL,
-  ** the file format becomes 3.
+  ** the file format be 3.  Back when this feature was first added
+  ** in 2006, we went to the trouble to upgrade the file format to the
+  ** minimum support values.  But 10-years on, we can assume that all
+  ** extent versions of SQLite support file-format 4, so we always and
+  ** unconditionally upgrade to 4.
   */
-  sqlite3MinimumFileFormat(pParse, iDb, pDflt ? 3 : 2);
+  sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, 
+                    SQLITE_MAX_FILE_FORMAT);
 
   /* Reload the schema of the modified table. */
   reloadTableSchema(pParse, pTab, pTab->zName);
@@ -90961,7 +91514,7 @@ SQLITE_PRIVATE void sqlite3AlterBeginAddColumn(Parse *pParse, SrcList *pSrc){
   pNew->aCol = (Column*)sqlite3DbMallocZero(db, sizeof(Column)*nAlloc);
   pNew->zName = sqlite3MPrintf(db, "sqlite_altertab_%s", pTab->zName);
   if( !pNew->aCol || !pNew->zName ){
-    db->mallocFailed = 1;
+    assert( db->mallocFailed );
     goto exit_begin_add_column;
   }
   memcpy(pNew->aCol, pTab->aCol, sizeof(Column)*pNew->nCol);
@@ -91306,7 +91859,7 @@ static void sampleClear(sqlite3 *db, Stat4Sample *p){
 static void sampleSetRowid(sqlite3 *db, Stat4Sample *p, int n, const u8 *pData){
   assert( db!=0 );
   if( p->nRowid ) sqlite3DbFree(db, p->u.aRowid);
-  p->u.aRowid = sqlite3DbMallocRaw(db, n);
+  p->u.aRowid = sqlite3DbMallocRawNN(db, n);
   if( p->u.aRowid ){
     p->nRowid = n;
     memcpy(p->u.aRowid, pData, n);
@@ -91471,8 +92024,7 @@ static const FuncDef statInitFuncdef = {
   SQLITE_UTF8,     /* funcFlags */
   0,               /* pUserData */
   0,               /* pNext */
-  statInit,        /* xFunc */
-  0,               /* xStep */
+  statInit,        /* xSFunc */
   0,               /* xFinalize */
   "stat_init",     /* zName */
   0,               /* pHash */
@@ -91772,8 +92324,7 @@ static const FuncDef statPushFuncdef = {
   SQLITE_UTF8,     /* funcFlags */
   0,               /* pUserData */
   0,               /* pNext */
-  statPush,        /* xFunc */
-  0,               /* xStep */
+  statPush,        /* xSFunc */
   0,               /* xFinalize */
   "stat_push",     /* zName */
   0,               /* pHash */
@@ -91919,8 +92470,7 @@ static const FuncDef statGetFuncdef = {
   SQLITE_UTF8,     /* funcFlags */
   0,               /* pUserData */
   0,               /* pNext */
-  statGet,         /* xFunc */
-  0,               /* xStep */
+  statGet,         /* xSFunc */
   0,               /* xFinalize */
   "stat_get",      /* zName */
   0,               /* pHash */
@@ -91936,8 +92486,8 @@ static void callStatGet(Vdbe *v, int regStat4, int iParam, int regOut){
 #else
   UNUSED_PARAMETER( iParam );
 #endif
-  sqlite3VdbeAddOp3(v, OP_Function0, 0, regStat4, regOut);
-  sqlite3VdbeChangeP4(v, -1, (char*)&statGetFuncdef, P4_FUNCDEF);
+  sqlite3VdbeAddOp4(v, OP_Function0, 0, regStat4, regOut,
+                    (char*)&statGetFuncdef, P4_FUNCDEF);
   sqlite3VdbeChangeP5(v, 1 + IsStat34);
 }
 
@@ -92091,8 +92641,8 @@ static void analyzeOneTable(
 #endif
     sqlite3VdbeAddOp2(v, OP_Integer, nCol, regStat4+1);
     sqlite3VdbeAddOp2(v, OP_Integer, pIdx->nKeyCol, regStat4+2);
-    sqlite3VdbeAddOp3(v, OP_Function0, 0, regStat4+1, regStat4);
-    sqlite3VdbeChangeP4(v, -1, (char*)&statInitFuncdef, P4_FUNCDEF);
+    sqlite3VdbeAddOp4(v, OP_Function0, 0, regStat4+1, regStat4,
+                     (char*)&statInitFuncdef, P4_FUNCDEF);
     sqlite3VdbeChangeP5(v, 2+IsStat34);
 
     /* Implementation of the following:
@@ -92111,7 +92661,7 @@ static void analyzeOneTable(
     if( nColTest>0 ){
       int endDistinctTest = sqlite3VdbeMakeLabel(v);
       int *aGotoChng;               /* Array of jump instruction addresses */
-      aGotoChng = sqlite3DbMallocRaw(db, sizeof(int)*nColTest);
+      aGotoChng = sqlite3DbMallocRawNN(db, sizeof(int)*nColTest);
       if( aGotoChng==0 ) continue;
 
       /*
@@ -92188,8 +92738,8 @@ static void analyzeOneTable(
     }
 #endif
     assert( regChng==(regStat4+1) );
-    sqlite3VdbeAddOp3(v, OP_Function0, 1, regStat4, regTemp);
-    sqlite3VdbeChangeP4(v, -1, (char*)&statPushFuncdef, P4_FUNCDEF);
+    sqlite3VdbeAddOp4(v, OP_Function0, 1, regStat4, regTemp,
+                     (char*)&statPushFuncdef, P4_FUNCDEF);
     sqlite3VdbeChangeP5(v, 2+IsStat34);
     sqlite3VdbeAddOp2(v, OP_Next, iIdxCur, addrNextRow); VdbeCoverage(v);
 
@@ -92519,7 +93069,7 @@ static int analysisLoader(void *pData, int argc, char **argv, char **NotUsed){
     ** the old data with the new instead of allocating a new array.  */
     if( pIndex->aiRowEst==0 ){
       pIndex->aiRowEst = (tRowcnt*)sqlite3MallocZero(sizeof(tRowcnt) * nCol);
-      if( pIndex->aiRowEst==0 ) pInfo->db->mallocFailed = 1;
+      if( pIndex->aiRowEst==0 ) sqlite3OomFault(pInfo->db);
     }
     aiRowEst = pIndex->aiRowEst;
 #endif
@@ -92666,7 +93216,7 @@ static int loadStatTbl(
   Index *pPrevIdx = 0;          /* Previous index in the loop */
   IndexSample *pSample;         /* A slot in pIdx->aSample[] */
 
-  assert( db->lookaside.bEnabled==0 );
+  assert( db->lookaside.bDisable );
   zSql = sqlite3MPrintf(db, zSql1, zDb);
   if( !zSql ){
     return SQLITE_NOMEM;
@@ -92780,7 +93330,7 @@ static int loadStatTbl(
 static int loadStat4(sqlite3 *db, const char *zDb){
   int rc = SQLITE_OK;             /* Result codes from subroutines */
 
-  assert( db->lookaside.bEnabled==0 );
+  assert( db->lookaside.bDisable );
   if( sqlite3FindTable(db, "sqlite_stat4", zDb) ){
     rc = loadStatTbl(db, 0,
       "SELECT idx,count(*) FROM %Q.sqlite_stat4 GROUP BY idx", 
@@ -92862,10 +93412,9 @@ SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
   /* Load the statistics from the sqlite_stat4 table. */
 #ifdef SQLITE_ENABLE_STAT3_OR_STAT4
   if( rc==SQLITE_OK && OptimizationEnabled(db, SQLITE_Stat34) ){
-    int lookasideEnabled = db->lookaside.bEnabled;
-    db->lookaside.bEnabled = 0;
+    db->lookaside.bDisable++;
     rc = loadStat4(db, sInfo.zDatabase);
-    db->lookaside.bEnabled = lookasideEnabled;
+    db->lookaside.bDisable--;
   }
   for(i=sqliteHashFirst(&db->aDb[iDb].pSchema->idxHash);i;i=sqliteHashNext(i)){
     Index *pIdx = sqliteHashData(i);
@@ -92875,7 +93424,7 @@ SQLITE_PRIVATE int sqlite3AnalysisLoad(sqlite3 *db, int iDb){
 #endif
 
   if( rc==SQLITE_NOMEM ){
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
   }
   return rc;
 }
@@ -92996,7 +93545,7 @@ static void attachFunc(
   ** hash tables.
   */
   if( db->aDb==db->aDbStatic ){
-    aNew = sqlite3DbMallocRaw(db, sizeof(db->aDb[0])*3 );
+    aNew = sqlite3DbMallocRawNN(db, sizeof(db->aDb[0])*3 );
     if( aNew==0 ) return;
     memcpy(aNew, db->aDb, sizeof(db->aDb[0])*2);
   }else{
@@ -93014,7 +93563,7 @@ static void attachFunc(
   flags = db->openFlags;
   rc = sqlite3ParseUri(db->pVfs->zName, zFile, &flags, &pVfs, &zPath, &zErr);
   if( rc!=SQLITE_OK ){
-    if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;
+    if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
     sqlite3_result_error(context, zErr, -1);
     sqlite3_free(zErr);
     return;
@@ -93043,7 +93592,8 @@ static void attachFunc(
     sqlite3BtreeSecureDelete(aNew->pBt,
                              sqlite3BtreeSecureDelete(db->aDb[0].pBt,-1) );
 #ifndef SQLITE_OMIT_PAGER_PRAGMAS
-    sqlite3BtreeSetPagerFlags(aNew->pBt, 3 | (db->flags & PAGER_FLAGS_MASK));
+    sqlite3BtreeSetPagerFlags(aNew->pBt,
+                      PAGER_SYNCHRONOUS_FULL | (db->flags & PAGER_FLAGS_MASK));
 #endif
     sqlite3BtreeLeave(aNew->pBt);
   }
@@ -93116,7 +93666,7 @@ static void attachFunc(
     sqlite3ResetAllSchemasOfConnection(db);
     db->nDb = iDb;
     if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
       sqlite3DbFree(db, zErrDyn);
       zErrDyn = sqlite3MPrintf(db, "out of memory");
     }else if( zErrDyn==0 ){
@@ -93246,11 +93796,11 @@ static void codeAttach(
 
   assert( v || db->mallocFailed );
   if( v ){
-    sqlite3VdbeAddOp3(v, OP_Function0, 0, regArgs+3-pFunc->nArg, regArgs+3);
+    sqlite3VdbeAddOp4(v, OP_Function0, 0, regArgs+3-pFunc->nArg, regArgs+3,
+                      (char *)pFunc, P4_FUNCDEF);
     assert( pFunc->nArg==-1 || (pFunc->nArg&0xff)==pFunc->nArg );
     sqlite3VdbeChangeP5(v, (u8)(pFunc->nArg));
-    sqlite3VdbeChangeP4(v, -1, (char *)pFunc, P4_FUNCDEF);
-
+ 
     /* Code an OP_Expire. For an ATTACH statement, set P1 to true (expire this
     ** statement only). For DETACH, set it to false (expire all existing
     ** statements).
@@ -93275,8 +93825,7 @@ SQLITE_PRIVATE void sqlite3Detach(Parse *pParse, Expr *pDbname){
     SQLITE_UTF8,      /* funcFlags */
     0,                /* pUserData */
     0,                /* pNext */
-    detachFunc,       /* xFunc */
-    0,                /* xStep */
+    detachFunc,       /* xSFunc */
     0,                /* xFinalize */
     "sqlite_detach",  /* zName */
     0,                /* pHash */
@@ -93296,8 +93845,7 @@ SQLITE_PRIVATE void sqlite3Attach(Parse *pParse, Expr *p, Expr *pDbname, Expr *p
     SQLITE_UTF8,      /* funcFlags */
     0,                /* pUserData */
     0,                /* pNext */
-    attachFunc,       /* xFunc */
-    0,                /* xStep */
+    attachFunc,       /* xSFunc */
     0,                /* xFinalize */
     "sqlite_attach",  /* zName */
     0,                /* pHash */
@@ -93761,15 +94309,6 @@ SQLITE_PRIVATE void sqlite3AuthContextPop(AuthContext *pContext){
 */
 /* #include "sqliteInt.h" */
 
-/*
-** This routine is called when a new SQL statement is beginning to
-** be parsed.  Initialize the pParse structure as needed.
-*/
-SQLITE_PRIVATE void sqlite3BeginParse(Parse *pParse, int explainFlag){
-  pParse->explain = (u8)explainFlag;
-  pParse->nVar = 0;
-}
-
 #ifndef SQLITE_OMIT_SHARED_CACHE
 /*
 ** The TableLock structure is only used by the sqlite3TableLock() and
@@ -93824,7 +94363,7 @@ SQLITE_PRIVATE void sqlite3TableLock(
     p->zName = zName;
   }else{
     pToplevel->nTableLock = 0;
-    pToplevel->db->mallocFailed = 1;
+    sqlite3OomFault(pToplevel->db);
   }
 }
 
@@ -93974,15 +94513,19 @@ SQLITE_PRIVATE void sqlite3FinishCoding(Parse *pParse){
     if( pParse->pAinc!=0 && pParse->nTab==0 ) pParse->nTab = 1;
     sqlite3VdbeMakeReady(v, pParse);
     pParse->rc = SQLITE_DONE;
-    pParse->colNamesSet = 0;
   }else{
     pParse->rc = SQLITE_ERROR;
   }
+
+  /* We are done with this Parse object. There is no need to de-initialize it */
+#if 0
+  pParse->colNamesSet = 0;
   pParse->nTab = 0;
   pParse->nMem = 0;
   pParse->nSet = 0;
   pParse->nVar = 0;
   DbMaskZero(pParse->cookieMask);
+#endif
 }
 
 /*
@@ -94241,7 +94784,6 @@ SQLITE_PRIVATE void sqlite3CollapseDatabaseArray(sqlite3 *db){
     }
     j++;
   }
-  memset(&db->aDb[j], 0, (db->nDb-j)*sizeof(db->aDb[j]));
   db->nDb = j;
   if( db->nDb<=2 && db->aDb!=db->aDbStatic ){
     memcpy(db->aDbStatic, db->aDb, 2*sizeof(db->aDb[0]));
@@ -94504,7 +95046,8 @@ SQLITE_PRIVATE int sqlite3TwoPartName(
   int iDb;                    /* Database holding the object */
   sqlite3 *db = pParse->db;
 
-  if( ALWAYS(pName2!=0) && pName2->n>0 ){
+  assert( pName2!=0 );
+  if( pName2->n>0 ){
     if( db->init.busy ) {
       sqlite3ErrorMsg(pParse, "corrupt database");
       return -1;
@@ -94593,62 +95136,46 @@ SQLITE_PRIVATE void sqlite3StartTable(
   int iDb;         /* Database number to create the table in */
   Token *pName;    /* Unqualified name of the table to create */
 
-  /* The table or view name to create is passed to this routine via tokens
-  ** pName1 and pName2. If the table name was fully qualified, for example:
-  **
-  ** CREATE TABLE xxx.yyy (...);
-  ** 
-  ** Then pName1 is set to "xxx" and pName2 "yyy". On the other hand if
-  ** the table name is not fully qualified, i.e.:
-  **
-  ** CREATE TABLE yyy(...);
-  **
-  ** Then pName1 is set to "yyy" and pName2 is "".
-  **
-  ** The call below sets the pName pointer to point at the token (pName1 or
-  ** pName2) that stores the unqualified table name. The variable iDb is
-  ** set to the index of the database that the table or view is to be
-  ** created in.
-  */
-  iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
-  if( iDb<0 ) return;
-  if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
-    /* If creating a temp table, the name may not be qualified. Unless 
-    ** the database name is "temp" anyway.  */
-    sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
-    return;
+  if( db->init.busy && db->init.newTnum==1 ){
+    /* Special case:  Parsing the sqlite_master or sqlite_temp_master schema */
+    iDb = db->init.iDb;
+    zName = sqlite3DbStrDup(db, SCHEMA_TABLE(iDb));
+    pName = pName1;
+  }else{
+    /* The common case */
+    iDb = sqlite3TwoPartName(pParse, pName1, pName2, &pName);
+    if( iDb<0 ) return;
+    if( !OMIT_TEMPDB && isTemp && pName2->n>0 && iDb!=1 ){
+      /* If creating a temp table, the name may not be qualified. Unless 
+      ** the database name is "temp" anyway.  */
+      sqlite3ErrorMsg(pParse, "temporary table name must be unqualified");
+      return;
+    }
+    if( !OMIT_TEMPDB && isTemp ) iDb = 1;
+    zName = sqlite3NameFromToken(db, pName);
   }
-  if( !OMIT_TEMPDB && isTemp ) iDb = 1;
-
   pParse->sNameToken = *pName;
-  zName = sqlite3NameFromToken(db, pName);
   if( zName==0 ) return;
   if( SQLITE_OK!=sqlite3CheckObjectName(pParse, zName) ){
     goto begin_table_error;
   }
   if( db->init.iDb==1 ) isTemp = 1;
 #ifndef SQLITE_OMIT_AUTHORIZATION
-  assert( (isTemp & 1)==isTemp );
+  assert( isTemp==0 || isTemp==1 );
+  assert( isView==0 || isView==1 );
   {
-    int code;
+    static const u8 aCode[] = {
+       SQLITE_CREATE_TABLE,
+       SQLITE_CREATE_TEMP_TABLE,
+       SQLITE_CREATE_VIEW,
+       SQLITE_CREATE_TEMP_VIEW
+    };
     char *zDb = db->aDb[iDb].zName;
     if( sqlite3AuthCheck(pParse, SQLITE_INSERT, SCHEMA_TABLE(isTemp), 0, zDb) ){
       goto begin_table_error;
     }
-    if( isView ){
-      if( !OMIT_TEMPDB && isTemp ){
-        code = SQLITE_CREATE_TEMP_VIEW;
-      }else{
-        code = SQLITE_CREATE_VIEW;
-      }
-    }else{
-      if( !OMIT_TEMPDB && isTemp ){
-        code = SQLITE_CREATE_TEMP_TABLE;
-      }else{
-        code = SQLITE_CREATE_TABLE;
-      }
-    }
-    if( !isVirtual && sqlite3AuthCheck(pParse, code, zName, 0, zDb) ){
+    if( !isVirtual && sqlite3AuthCheck(pParse, (int)aCode[isTemp+2*isView],
+                                       zName, 0, zDb) ){
       goto begin_table_error;
     }
   }
@@ -94684,7 +95211,7 @@ SQLITE_PRIVATE void sqlite3StartTable(
 
   pTable = sqlite3DbMallocZero(db, sizeof(Table));
   if( pTable==0 ){
-    db->mallocFailed = 1;
+    assert( db->mallocFailed );
     pParse->rc = SQLITE_NOMEM;
     pParse->nErr++;
     goto begin_table_error;
@@ -94741,10 +95268,8 @@ SQLITE_PRIVATE void sqlite3StartTable(
     addr1 = sqlite3VdbeAddOp1(v, OP_If, reg3); VdbeCoverage(v);
     fileFormat = (db->flags & SQLITE_LegacyFileFmt)!=0 ?
                   1 : SQLITE_MAX_FILE_FORMAT;
-    sqlite3VdbeAddOp2(v, OP_Integer, fileFormat, reg3);
-    sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, reg3);
-    sqlite3VdbeAddOp2(v, OP_Integer, ENC(db), reg3);
-    sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, reg3);
+    sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_FILE_FORMAT, fileFormat);
+    sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_TEXT_ENCODING, ENC(db));
     sqlite3VdbeJumpHere(v, addr1);
 
     /* This just creates a place-holder record in the sqlite_master table.
@@ -95229,13 +95754,11 @@ SQLITE_PRIVATE CollSeq *sqlite3LocateCollSeq(Parse *pParse, const char *zName){
 ** 1 chance in 2^32.  So we're safe enough.
 */
 SQLITE_PRIVATE void sqlite3ChangeCookie(Parse *pParse, int iDb){
-  int r1 = sqlite3GetTempReg(pParse);
   sqlite3 *db = pParse->db;
   Vdbe *v = pParse->pVdbe;
   assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
-  sqlite3VdbeAddOp2(v, OP_Integer, db->aDb[iDb].pSchema->schema_cookie+1, r1);
-  sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION, r1);
-  sqlite3ReleaseTempReg(pParse, r1);
+  sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_SCHEMA_VERSION, 
+                    db->aDb[iDb].pSchema->schema_cookie+1);
 }
 
 /*
@@ -95317,7 +95840,7 @@ static char *createTableStmt(sqlite3 *db, Table *p){
   n += 35 + 6*p->nCol;
   zStmt = sqlite3DbMallocRaw(0, n);
   if( zStmt==0 ){
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
     return 0;
   }
   sqlite3_snprintf(n, zStmt, "CREATE TABLE ");
@@ -95466,8 +95989,7 @@ static void convertToWithoutRowidTable(Parse *pParse, Table *pTab){
   if( pTab->iPKey>=0 ){
     ExprList *pList;
     Token ipkToken;
-    ipkToken.z = pTab->aCol[pTab->iPKey].zName;
-    ipkToken.n = sqlite3Strlen30(ipkToken.z);
+    sqlite3TokenInit(&ipkToken, pTab->aCol[pTab->iPKey].zName);
     pList = sqlite3ExprListAppend(pParse, 0, 
                   sqlite3ExprAlloc(db, TK_ID, &ipkToken, 0));
     if( pList==0 ) return;
@@ -95610,9 +96132,13 @@ SQLITE_PRIVATE void sqlite3EndTable(
   ** So do not write to the disk again.  Extract the root page number
   ** for the table from the db->init.newTnum field.  (The page number
   ** should have been put there by the sqliteOpenCb routine.)
+  **
+  ** If the root page number is 1, that means this is the sqlite_master
+  ** table itself.  So mark it read-only.
   */
   if( db->init.busy ){
     p->tnum = db->init.newTnum;
+    if( p->tnum==1 ) p->tabFlags |= TF_Readonly;
   }
 
   /* Special processing for WITHOUT ROWID Tables */
@@ -95713,7 +96239,7 @@ SQLITE_PRIVATE void sqlite3EndTable(
       sqlite3VdbeAddOp3(v, OP_InitCoroutine, regYield, 0, addrTop);
       sqlite3SelectDestInit(&dest, SRT_Coroutine, regYield);
       sqlite3Select(pParse, pSelect, &dest);
-      sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield);
+      sqlite3VdbeEndCoroutine(v, regYield);
       sqlite3VdbeJumpHere(v, addrTop - 1);
       if( pParse->nErr ) return;
       pSelTab = sqlite3ResultSetOfSelect(pParse, pSelect);
@@ -95797,7 +96323,7 @@ SQLITE_PRIVATE void sqlite3EndTable(
     pOld = sqlite3HashInsert(&pSchema->tblHash, p->zName, p);
     if( pOld ){
       assert( p==pOld );  /* Malloc must have failed inside HashInsert() */
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
       return;
     }
     pParse->pNewTable = 0;
@@ -95901,7 +96427,6 @@ SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
   int n;            /* Temporarily holds the number of cursors assigned */
   sqlite3 *db = pParse->db;  /* Database connection for malloc errors */
   sqlite3_xauth xAuth;       /* Saved xAuth pointer */
-  u8 bEnabledLA;             /* Saved db->lookaside.bEnabled state */
 
   assert( pTable );
 
@@ -95947,18 +96472,18 @@ SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
   ** statement that defines the view.
   */
   assert( pTable->pSelect );
-  bEnabledLA = db->lookaside.bEnabled;
   if( pTable->pCheck ){
-    db->lookaside.bEnabled = 0;
+    db->lookaside.bDisable++;
     sqlite3ColumnsFromExprList(pParse, pTable->pCheck, 
                                &pTable->nCol, &pTable->aCol);
+    db->lookaside.bDisable--;
   }else{
     pSel = sqlite3SelectDup(db, pTable->pSelect, 0);
     if( pSel ){
       n = pParse->nTab;
       sqlite3SrcListAssignCursors(pParse, pSel->pSrc);
       pTable->nCol = -1;
-      db->lookaside.bEnabled = 0;
+      db->lookaside.bDisable++;
 #ifndef SQLITE_OMIT_AUTHORIZATION
       xAuth = db->xAuth;
       db->xAuth = 0;
@@ -95967,6 +96492,7 @@ SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
 #else
       pSelTab = sqlite3ResultSetOfSelect(pParse, pSel);
 #endif
+      db->lookaside.bDisable--;
       pParse->nTab = n;
       if( pSelTab ){
         assert( pTable->aCol==0 );
@@ -95985,7 +96511,6 @@ SQLITE_PRIVATE int sqlite3ViewGetColumnNames(Parse *pParse, Table *pTable){
       nErr++;
     }
   }
-  db->lookaside.bEnabled = bEnabledLA;
   pTable->pSchema->schemaFlags |= DB_UnresetViews;
 #endif /* SQLITE_OMIT_VIEW */
   return nErr;  
@@ -96065,6 +96590,7 @@ SQLITE_PRIVATE void sqlite3RootPageMoved(sqlite3 *db, int iDb, int iFrom, int iT
 static void destroyRootPage(Parse *pParse, int iTable, int iDb){
   Vdbe *v = sqlite3GetVdbe(pParse);
   int r1 = sqlite3GetTempReg(pParse);
+  assert( iTable>1 );
   sqlite3VdbeAddOp3(v, OP_Destroy, iTable, r1, iDb);
   sqlite3MayAbort(pParse);
 #ifndef SQLITE_OMIT_AUTOVACUUM
@@ -96450,7 +96976,7 @@ SQLITE_PRIVATE void sqlite3CreateForeignKey(
       pFKey->zTo, (void *)pFKey
   );
   if( pNextTo==pFKey ){
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
     goto fk_end;
   }
   if( pNextTo ){
@@ -96810,8 +97336,7 @@ SQLITE_PRIVATE Index *sqlite3CreateIndex(
   */
   if( pList==0 ){
     Token prevCol;
-    prevCol.z = pTab->aCol[pTab->nCol-1].zName;
-    prevCol.n = sqlite3Strlen30(prevCol.z);
+    sqlite3TokenInit(&prevCol, pTab->aCol[pTab->nCol-1].zName);
     pList = sqlite3ExprListAppend(pParse, 0,
               sqlite3ExprAlloc(db, TK_ID, &prevCol, 0));
     if( pList==0 ) goto exit_create_index;
@@ -97033,7 +97558,7 @@ SQLITE_PRIVATE Index *sqlite3CreateIndex(
                           pIndex->zName, pIndex);
     if( p ){
       assert( p==pIndex );  /* Malloc must have failed */
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
       goto exit_create_index;
     }
     db->flags |= SQLITE_InternChanges;
@@ -97462,10 +97987,12 @@ SQLITE_PRIVATE SrcList *sqlite3SrcListAppend(
 ){
   struct SrcList_item *pItem;
   assert( pDatabase==0 || pTable!=0 );  /* Cannot have C without B */
+  assert( db!=0 );
   if( pList==0 ){
-    pList = sqlite3DbMallocZero(db, sizeof(SrcList) );
+    pList = sqlite3DbMallocRawNN(db, sizeof(SrcList) );
     if( pList==0 ) return 0;
     pList->nAlloc = 1;
+    pList->nSrc = 0;
   }
   pList = sqlite3SrcListEnlarge(db, pList, 1, pList->nSrc);
   if( db->mallocFailed ){
@@ -97646,7 +98173,7 @@ SQLITE_PRIVATE void sqlite3SrcListShiftJoinType(SrcList *p){
 }
 
 /*
-** Begin a transaction
+** Generate VDBE code for a BEGIN statement.
 */
 SQLITE_PRIVATE void sqlite3BeginTransaction(Parse *pParse, int type){
   sqlite3 *db;
@@ -97656,7 +98183,6 @@ SQLITE_PRIVATE void sqlite3BeginTransaction(Parse *pParse, int type){
   assert( pParse!=0 );
   db = pParse->db;
   assert( db!=0 );
-/*  if( db->aDb[0].pBt==0 ) return; */
   if( sqlite3AuthCheck(pParse, SQLITE_TRANSACTION, "BEGIN", 0, 0) ){
     return;
   }
@@ -97668,11 +98194,11 @@ SQLITE_PRIVATE void sqlite3BeginTransaction(Parse *pParse, int type){
       sqlite3VdbeUsesBtree(v, i);
     }
   }
-  sqlite3VdbeAddOp2(v, OP_AutoCommit, 0, 0);
+  sqlite3VdbeAddOp0(v, OP_AutoCommit);
 }
 
 /*
-** Commit a transaction
+** Generate VDBE code for a COMMIT statement.
 */
 SQLITE_PRIVATE void sqlite3CommitTransaction(Parse *pParse){
   Vdbe *v;
@@ -97684,12 +98210,12 @@ SQLITE_PRIVATE void sqlite3CommitTransaction(Parse *pParse){
   }
   v = sqlite3GetVdbe(pParse);
   if( v ){
-    sqlite3VdbeAddOp2(v, OP_AutoCommit, 1, 0);
+    sqlite3VdbeAddOp1(v, OP_AutoCommit, 1);
   }
 }
 
 /*
-** Rollback a transaction
+** Generate VDBE code for a ROLLBACK statement.
 */
 SQLITE_PRIVATE void sqlite3RollbackTransaction(Parse *pParse){
   Vdbe *v;
@@ -97751,7 +98277,7 @@ SQLITE_PRIVATE int sqlite3OpenTempDatabase(Parse *pParse){
     db->aDb[1].pBt = pBt;
     assert( db->aDb[1].pSchema );
     if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize, -1, 0) ){
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
       return 1;
     }
   }
@@ -97868,7 +98394,7 @@ SQLITE_PRIVATE void sqlite3HaltConstraint(
     sqlite3MayAbort(pParse);
   }
   sqlite3VdbeAddOp4(v, OP_Halt, errCode, onError, 0, p4, p4type);
-  if( p5Errmsg ) sqlite3VdbeChangeP5(v, p5Errmsg);
+  sqlite3VdbeChangeP5(v, p5Errmsg);
 }
 
 /*
@@ -97886,14 +98412,14 @@ SQLITE_PRIVATE void sqlite3UniqueConstraint(
 
   sqlite3StrAccumInit(&errMsg, pParse->db, 0, 0, 200);
   if( pIdx->aColExpr ){
-    sqlite3XPrintf(&errMsg, 0, "index '%q'", pIdx->zName);
+    sqlite3XPrintf(&errMsg, "index '%q'", pIdx->zName);
   }else{
     for(j=0; j<pIdx->nKeyCol; j++){
       char *zCol;
       assert( pIdx->aiColumn[j]>=0 );
       zCol = pTab->aCol[pIdx->aiColumn[j]].zName;
       if( j ) sqlite3StrAccumAppend(&errMsg, ", ", 2);
-      sqlite3XPrintf(&errMsg, 0, "%s.%s", pTab->zName, zCol);
+      sqlite3XPrintf(&errMsg, "%s.%s", pTab->zName, zCol);
     }
   }
   zErr = sqlite3StrAccumFinish(&errMsg);
@@ -98126,10 +98652,9 @@ SQLITE_PRIVATE With *sqlite3WithAdd(
   }else{
     pNew = sqlite3DbMallocZero(db, sizeof(*pWith));
   }
-  assert( zName!=0 || pNew==0 );
-  assert( db->mallocFailed==0 || pNew==0 );
+  assert( (pNew!=0 && zName!=0) || db->mallocFailed );
 
-  if( pNew==0 ){
+  if( db->mallocFailed ){
     sqlite3ExprListDelete(db, pArglist);
     sqlite3SelectDelete(db, pQuery);
     sqlite3DbFree(db, zName);
@@ -98343,7 +98868,7 @@ static CollSeq *findCollSeqEntry(
       */
       assert( pDel==0 || pDel==pColl );
       if( pDel!=0 ){
-        db->mallocFailed = 1;
+        sqlite3OomFault(db);
         sqlite3DbFree(db, pDel);
         pColl = 0;
       }
@@ -98409,8 +98934,8 @@ SQLITE_PRIVATE CollSeq *sqlite3FindCollSeq(
 ** 5: UTF16 byte order conversion required - argument count matches exactly
 ** 6: Perfect match:  encoding and argument count match exactly.
 **
-** If nArg==(-2) then any function with a non-null xStep or xFunc is
-** a perfect match and any function with both xStep and xFunc NULL is
+** If nArg==(-2) then any function with a non-null xSFunc is
+** a perfect match and any function with xSFunc NULL is
 ** a non-match.
 */
 #define FUNC_PERFECT_MATCH 6  /* The score for a perfect match */
@@ -98422,7 +98947,7 @@ static int matchQuality(
   int match;
 
   /* nArg of -2 is a special case */
-  if( nArg==(-2) ) return (p->xFunc==0 && p->xStep==0) ? 0 : FUNC_PERFECT_MATCH;
+  if( nArg==(-2) ) return (p->xSFunc==0) ? 0 : FUNC_PERFECT_MATCH;
 
   /* Wrong number of arguments means "no match" */
   if( p->nArg!=nArg && p->nArg>=0 ) return 0;
@@ -98500,7 +99025,7 @@ SQLITE_PRIVATE void sqlite3FuncDefInsert(
 ** no matching function previously existed.
 **
 ** If nArg is -2, then the first valid function found is returned.  A
-** function is valid if either xFunc or xStep is non-zero.  The nArg==(-2)
+** function is valid if xSFunc is non-zero.  The nArg==(-2)
 ** case is used to see if zName is a valid function name for some number
 ** of arguments.  If nArg is -2, then createFlag must be 0.
 **
@@ -98577,7 +99102,7 @@ SQLITE_PRIVATE FuncDef *sqlite3FindFunction(
     sqlite3FuncDefInsert(&db->aFunc, pBest);
   }
 
-  if( pBest && (pBest->xStep || pBest->xFunc || createFlag) ){
+  if( pBest && (pBest->xSFunc || createFlag) ){
     return pBest;
   }
   return 0;
@@ -98631,7 +99156,7 @@ SQLITE_PRIVATE Schema *sqlite3SchemaGet(sqlite3 *db, Btree *pBt){
     p = (Schema *)sqlite3DbMallocZero(0, sizeof(Schema));
   }
   if( !p ){
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
   }else if ( 0==p->file_format ){
     sqlite3HashInit(&p->tblHash);
     sqlite3HashInit(&p->idxHash);
@@ -99085,7 +99610,7 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(
       ** one, so just keep it in its register(s) and fall through to the
       ** delete code.  */
       nKey = nPk; /* OP_Found will use an unpacked key */
-      aToOpen = sqlite3DbMallocRaw(db, nIdx+2);
+      aToOpen = sqlite3DbMallocRawNN(db, nIdx+2);
       if( aToOpen==0 ){
         sqlite3WhereEnd(pWInfo);
         goto delete_from_cleanup;
@@ -99125,13 +99650,12 @@ SQLITE_PRIVATE void sqlite3DeleteFrom(
     */
     if( !isView ){
       int iAddrOnce = 0;
-      u8 p5 = (eOnePass==ONEPASS_OFF ? 0 : OPFLAG_FORDELETE);
       if( eOnePass==ONEPASS_MULTI ){
         iAddrOnce = sqlite3CodeOnce(pParse); VdbeCoverage(v);
       }
       testcase( IsVirtual(pTab) );
-      sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, p5, iTabCur, 
-                                 aToOpen, &iDataCur, &iIdxCur);
+      sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, OPFLAG_FORDELETE,
+                                 iTabCur, aToOpen, &iDataCur, &iIdxCur);
       assert( pPk || IsVirtual(pTab) || iDataCur==iTabCur );
       assert( pPk || IsVirtual(pTab) || iIdxCur==iDataCur+1 );
       if( eOnePass==ONEPASS_MULTI ) sqlite3VdbeJumpHere(v, iAddrOnce);
@@ -99364,15 +99888,20 @@ SQLITE_PRIVATE void sqlite3GenerateRowDelete(
   ** a view (in which case the only effect of the DELETE statement is to
   ** fire the INSTEAD OF triggers).  */ 
   if( pTab->pSelect==0 ){
+    u8 p5 = 0;
     sqlite3GenerateRowIndexDelete(pParse, pTab, iDataCur, iIdxCur,0,iIdxNoSeek);
     sqlite3VdbeAddOp2(v, OP_Delete, iDataCur, (count?OPFLAG_NCHANGE:0));
     if( count ){
       sqlite3VdbeChangeP4(v, -1, pTab->zName, P4_TRANSIENT);
     }
+    if( eMode!=ONEPASS_OFF ){
+      sqlite3VdbeChangeP5(v, OPFLAG_AUXDELETE);
+    }
     if( iIdxNoSeek>=0 ){
       sqlite3VdbeAddOp1(v, OP_Delete, iIdxNoSeek);
     }
-    sqlite3VdbeChangeP5(v, eMode==ONEPASS_MULTI);
+    if( eMode==ONEPASS_MULTI ) p5 |= OPFLAG_SAVEPOSITION;
+    sqlite3VdbeChangeP5(v, p5);
   }
 
   /* Do any ON CASCADE, SET NULL or SET DEFAULT operations required to
@@ -99782,7 +100311,8 @@ static void printfFunc(
     x.nUsed = 0;
     x.apArg = argv+1;
     sqlite3StrAccumInit(&str, db, 0, 0, db->aLimit[SQLITE_LIMIT_LENGTH]);
-    sqlite3XPrintf(&str, SQLITE_PRINTF_SQLFUNC, zFormat, &x);
+    str.printfFlags = SQLITE_PRINTF_SQLFUNC;
+    sqlite3XPrintf(&str, zFormat, &x);
     n = str.nChar;
     sqlite3_result_text(context, sqlite3StrAccumFinish(&str), n,
                         SQLITE_DYNAMIC);
@@ -100110,10 +100640,10 @@ static void total_changes(
 ** A structure defining how to do GLOB-style comparisons.
 */
 struct compareInfo {
-  u8 matchAll;
-  u8 matchOne;
-  u8 matchSet;
-  u8 noCase;
+  u8 matchAll;          /* "*" or "%" */
+  u8 matchOne;          /* "?" or "_" */
+  u8 matchSet;          /* "[" or 0 */
+  u8 noCase;            /* true to ignore case differences */
 };
 
 /*
@@ -100176,22 +100706,14 @@ static int patternCompare(
   const u8 *zPattern,              /* The glob pattern */
   const u8 *zString,               /* The string to compare against the glob */
   const struct compareInfo *pInfo, /* Information about how to do the compare */
-  u32 esc                          /* The escape character */
+  u32 matchOther                   /* The escape char (LIKE) or '[' (GLOB) */
 ){
   u32 c, c2;                       /* Next pattern and input string chars */
   u32 matchOne = pInfo->matchOne;  /* "?" or "_" */
   u32 matchAll = pInfo->matchAll;  /* "*" or "%" */
-  u32 matchOther;                  /* "[" or the escape character */
   u8 noCase = pInfo->noCase;       /* True if uppercase==lowercase */
   const u8 *zEscaped = 0;          /* One past the last escaped input char */
   
-  /* The GLOB operator does not have an ESCAPE clause.  And LIKE does not
-  ** have the matchSet operator.  So we either have to look for one or
-  ** the other, never both.  Hence the single variable matchOther is used
-  ** to store the one we have to look for.
-  */
-  matchOther = esc ? esc : pInfo->matchSet;
-
   while( (c = Utf8Read(zPattern))!=0 ){
     if( c==matchAll ){  /* Match "*" */
       /* Skip over multiple "*" characters in the pattern.  If there
@@ -100205,7 +100727,7 @@ static int patternCompare(
       if( c==0 ){
         return 1;   /* "*" at the end of the pattern matches */
       }else if( c==matchOther ){
-        if( esc ){
+        if( pInfo->matchSet==0 ){
           c = sqlite3Utf8Read(&zPattern);
           if( c==0 ) return 0;
         }else{
@@ -100213,7 +100735,7 @@ static int patternCompare(
           ** recursive search in this case, but it is an unusual case. */
           assert( matchOther<0x80 );  /* '[' is a single-byte character */
           while( *zString
-                 && patternCompare(&zPattern[-1],zString,pInfo,esc)==0 ){
+                 && patternCompare(&zPattern[-1],zString,pInfo,matchOther)==0 ){
             SQLITE_SKIP_UTF8(zString);
           }
           return *zString!=0;
@@ -100239,18 +100761,18 @@ static int patternCompare(
         }
         while( (c2 = *(zString++))!=0 ){
           if( c2!=c && c2!=cx ) continue;
-          if( patternCompare(zPattern,zString,pInfo,esc) ) return 1;
+          if( patternCompare(zPattern,zString,pInfo,matchOther) ) return 1;
         }
       }else{
         while( (c2 = Utf8Read(zString))!=0 ){
           if( c2!=c ) continue;
-          if( patternCompare(zPattern,zString,pInfo,esc) ) return 1;
+          if( patternCompare(zPattern,zString,pInfo,matchOther) ) return 1;
         }
       }
       return 0;
     }
     if( c==matchOther ){
-      if( esc ){
+      if( pInfo->matchSet==0 ){
         c = sqlite3Utf8Read(&zPattern);
         if( c==0 ) return 0;
         zEscaped = zPattern;
@@ -100303,7 +100825,7 @@ static int patternCompare(
 ** The sqlite3_strglob() interface.
 */
 SQLITE_API int SQLITE_STDCALL sqlite3_strglob(const char *zGlobPattern, const char *zString){
-  return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, 0)==0;
+  return patternCompare((u8*)zGlobPattern, (u8*)zString, &globInfo, '[')==0;
 }
 
 /*
@@ -100341,9 +100863,10 @@ static void likeFunc(
   sqlite3_value **argv
 ){
   const unsigned char *zA, *zB;
-  u32 escape = 0;
+  u32 escape;
   int nPat;
   sqlite3 *db = sqlite3_context_db_handle(context);
+  struct compareInfo *pInfo = sqlite3_user_data(context);
 
 #ifdef SQLITE_LIKE_DOESNT_MATCH_BLOBS
   if( sqlite3_value_type(argv[0])==SQLITE_BLOB
@@ -100383,13 +100906,13 @@ static void likeFunc(
       return;
     }
     escape = sqlite3Utf8Read(&zEsc);
+  }else{
+    escape = pInfo->matchSet;
   }
   if( zA && zB ){
-    struct compareInfo *pInfo = sqlite3_user_data(context);
 #ifdef SQLITE_TEST
     sqlite3_like_count++;
 #endif
-    
     sqlite3_result_int(context, patternCompare(zB, zA, pInfo, escape));
   }
 }
@@ -101164,7 +101687,7 @@ SQLITE_PRIVATE void sqlite3RegisterBuiltinFunctions(sqlite3 *db){
   int rc = sqlite3_overload_function(db, "MATCH", 2);
   assert( rc==SQLITE_NOMEM || rc==SQLITE_OK );
   if( rc==SQLITE_NOMEM ){
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
   }
 }
 
@@ -101579,7 +102102,7 @@ SQLITE_PRIVATE int sqlite3FkLocateIndex(
     }
   }else if( paiCol ){
     assert( nCol>1 );
-    aiCol = (int *)sqlite3DbMallocRaw(pParse->db, nCol*sizeof(int));
+    aiCol = (int *)sqlite3DbMallocRawNN(pParse->db, nCol*sizeof(int));
     if( !aiCol ) return 1;
     *paiCol = aiCol;
   }
@@ -102525,7 +103048,6 @@ static Trigger *fkActionTrigger(
   pTrigger = pFKey->apTrigger[iAction];
 
   if( action!=OE_None && !pTrigger ){
-    u8 enableLookaside;           /* Copy of db->lookaside.bEnabled */
     char const *zFrom;            /* Name of child table */
     int nFrom;                    /* Length in bytes of zFrom */
     Index *pIdx = 0;              /* Parent key index for this FK */
@@ -102552,11 +103074,9 @@ static Trigger *fkActionTrigger(
       assert( iFromCol>=0 );
       assert( pIdx!=0 || (pTab->iPKey>=0 && pTab->iPKey<pTab->nCol) );
       assert( pIdx==0 || pIdx->aiColumn[i]>=0 );
-      tToCol.z = pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zName;
-      tFromCol.z = pFKey->pFrom->aCol[iFromCol].zName;
-
-      tToCol.n = sqlite3Strlen30(tToCol.z);
-      tFromCol.n = sqlite3Strlen30(tFromCol.z);
+      sqlite3TokenInit(&tToCol,
+                   pTab->aCol[pIdx ? pIdx->aiColumn[i] : pTab->iPKey].zName);
+      sqlite3TokenInit(&tFromCol, pFKey->pFrom->aCol[iFromCol].zName);
 
       /* Create the expression "OLD.zToCol = zFromCol". It is important
       ** that the "OLD.zToCol" term is on the LHS of the = operator, so
@@ -102636,8 +103156,7 @@ static Trigger *fkActionTrigger(
     }
 
     /* Disable lookaside memory allocation */
-    enableLookaside = db->lookaside.bEnabled;
-    db->lookaside.bEnabled = 0;
+    db->lookaside.bDisable++;
 
     pTrigger = (Trigger *)sqlite3DbMallocZero(db, 
         sizeof(Trigger) +         /* struct Trigger */
@@ -102659,7 +103178,7 @@ static Trigger *fkActionTrigger(
     }
 
     /* Re-enable the lookaside buffer, if it was disabled earlier. */
-    db->lookaside.bEnabled = enableLookaside;
+    db->lookaside.bDisable--;
 
     sqlite3ExprDelete(db, pWhere);
     sqlite3ExprDelete(db, pWhen);
@@ -102854,7 +103373,7 @@ SQLITE_PRIVATE const char *sqlite3IndexAffinityStr(sqlite3 *db, Index *pIdx){
     Table *pTab = pIdx->pTable;
     pIdx->zColAff = (char *)sqlite3DbMallocRaw(0, pIdx->nColumn+1);
     if( !pIdx->zColAff ){
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
       return 0;
     }
     for(n=0; n<pIdx->nColumn; n++){
@@ -102905,7 +103424,7 @@ SQLITE_PRIVATE void sqlite3TableAffinity(Vdbe *v, Table *pTab, int iReg){
     sqlite3 *db = sqlite3VdbeDb(v);
     zColAff = (char *)sqlite3DbMallocRaw(0, pTab->nCol+1);
     if( !zColAff ){
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
       return;
     }
 
@@ -103001,7 +103520,7 @@ static int autoIncBegin(
     pInfo = pToplevel->pAinc;
     while( pInfo && pInfo->pTab!=pTab ){ pInfo = pInfo->pNext; }
     if( pInfo==0 ){
-      pInfo = sqlite3DbMallocRaw(pParse->db, sizeof(*pInfo));
+      pInfo = sqlite3DbMallocRawNN(pParse->db, sizeof(*pInfo));
       if( pInfo==0 ) return 0;
       pInfo->pNext = pToplevel->pAinc;
       pToplevel->pAinc = pInfo;
@@ -103025,7 +103544,6 @@ SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse){
   sqlite3 *db = pParse->db;  /* The database connection */
   Db *pDb;                   /* Database only autoinc table */
   int memId;                 /* Register holding max rowid */
-  int addr;                  /* A VDBE address */
   Vdbe *v = pParse->pVdbe;   /* VDBE under construction */
 
   /* This routine is never called during trigger-generation.  It is
@@ -103035,33 +103553,46 @@ SQLITE_PRIVATE void sqlite3AutoincrementBegin(Parse *pParse){
 
   assert( v );   /* We failed long ago if this is not so */
   for(p = pParse->pAinc; p; p = p->pNext){
+    static const int iLn = VDBE_OFFSET_LINENO(2);
+    static const VdbeOpList autoInc[] = {
+      /* 0  */ {OP_Null,    0,  0, 0},
+      /* 1  */ {OP_Rewind,  0,  9, 0},
+      /* 2  */ {OP_Column,  0,  0, 0},
+      /* 3  */ {OP_Ne,      0,  7, 0},
+      /* 4  */ {OP_Rowid,   0,  0, 0},
+      /* 5  */ {OP_Column,  0,  1, 0},
+      /* 6  */ {OP_Goto,    0,  9, 0},
+      /* 7  */ {OP_Next,    0,  2, 0},
+      /* 8  */ {OP_Integer, 0,  0, 0},
+      /* 9  */ {OP_Close,   0,  0, 0} 
+    };
+    VdbeOp *aOp;
     pDb = &db->aDb[p->iDb];
     memId = p->regCtr;
     assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
     sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenRead);
-    sqlite3VdbeAddOp3(v, OP_Null, 0, memId, memId+1);
-    addr = sqlite3VdbeCurrentAddr(v);
     sqlite3VdbeLoadString(v, memId-1, p->pTab->zName);
-    sqlite3VdbeAddOp2(v, OP_Rewind, 0, addr+9); VdbeCoverage(v);
-    sqlite3VdbeAddOp3(v, OP_Column, 0, 0, memId);
-    sqlite3VdbeAddOp3(v, OP_Ne, memId-1, addr+7, memId); VdbeCoverage(v);
-    sqlite3VdbeChangeP5(v, SQLITE_JUMPIFNULL);
-    sqlite3VdbeAddOp2(v, OP_Rowid, 0, memId+1);
-    sqlite3VdbeAddOp3(v, OP_Column, 0, 1, memId);
-    sqlite3VdbeGoto(v, addr+9);
-    sqlite3VdbeAddOp2(v, OP_Next, 0, addr+2); VdbeCoverage(v);
-    sqlite3VdbeAddOp2(v, OP_Integer, 0, memId);
-    sqlite3VdbeAddOp0(v, OP_Close);
+    aOp = sqlite3VdbeAddOpList(v, ArraySize(autoInc), autoInc, iLn);
+    if( aOp==0 ) break;
+    aOp[0].p2 = memId;
+    aOp[0].p3 = memId+1;
+    aOp[2].p3 = memId;
+    aOp[3].p1 = memId-1;
+    aOp[3].p3 = memId;
+    aOp[3].p5 = SQLITE_JUMPIFNULL;
+    aOp[4].p2 = memId+1;
+    aOp[5].p3 = memId;
+    aOp[8].p2 = memId;
   }
 }
 
 /*
 ** Update the maximum rowid for an autoincrement calculation.
 **
-** This routine should be called when the top of the stack holds a
+** This routine should be called when the regRowid register holds a
 ** new rowid that is about to be inserted.  If that new rowid is
 ** larger than the maximum rowid in the memId memory cell, then the
-** memory cell is updated.  The stack is unchanged.
+** memory cell is updated.
 */
 static void autoIncStep(Parse *pParse, int memId, int regRowid){
   if( memId>0 ){
@@ -103076,31 +103607,44 @@ static void autoIncStep(Parse *pParse, int memId, int regRowid){
 ** table (either directly or through triggers) needs to call this
 ** routine just before the "exit" code.
 */
-SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse){
+static SQLITE_NOINLINE void autoIncrementEnd(Parse *pParse){
   AutoincInfo *p;
   Vdbe *v = pParse->pVdbe;
   sqlite3 *db = pParse->db;
 
   assert( v );
   for(p = pParse->pAinc; p; p = p->pNext){
+    static const int iLn = VDBE_OFFSET_LINENO(2);
+    static const VdbeOpList autoIncEnd[] = {
+      /* 0 */ {OP_NotNull,     0, 2, 0},
+      /* 1 */ {OP_NewRowid,    0, 0, 0},
+      /* 2 */ {OP_MakeRecord,  0, 2, 0},
+      /* 3 */ {OP_Insert,      0, 0, 0},
+      /* 4 */ {OP_Close,       0, 0, 0}
+    };
+    VdbeOp *aOp;
     Db *pDb = &db->aDb[p->iDb];
-    int addr1;
     int iRec;
     int memId = p->regCtr;
 
     iRec = sqlite3GetTempReg(pParse);
     assert( sqlite3SchemaMutexHeld(db, 0, pDb->pSchema) );
     sqlite3OpenTable(pParse, 0, p->iDb, pDb->pSchema->pSeqTab, OP_OpenWrite);
-    addr1 = sqlite3VdbeAddOp1(v, OP_NotNull, memId+1); VdbeCoverage(v);
-    sqlite3VdbeAddOp2(v, OP_NewRowid, 0, memId+1);
-    sqlite3VdbeJumpHere(v, addr1);
-    sqlite3VdbeAddOp3(v, OP_MakeRecord, memId-1, 2, iRec);
-    sqlite3VdbeAddOp3(v, OP_Insert, 0, iRec, memId+1);
-    sqlite3VdbeChangeP5(v, OPFLAG_APPEND);
-    sqlite3VdbeAddOp0(v, OP_Close);
+    aOp = sqlite3VdbeAddOpList(v, ArraySize(autoIncEnd), autoIncEnd, iLn);
+    if( aOp==0 ) break;
+    aOp[0].p1 = memId+1;
+    aOp[1].p2 = memId+1;
+    aOp[2].p1 = memId-1;
+    aOp[2].p3 = iRec;
+    aOp[3].p2 = iRec;
+    aOp[3].p3 = memId+1;
+    aOp[3].p5 = OPFLAG_APPEND;
     sqlite3ReleaseTempReg(pParse, iRec);
   }
 }
+SQLITE_PRIVATE void sqlite3AutoincrementEnd(Parse *pParse){
+  if( pParse->pAinc ) autoIncrementEnd(pParse);
+}
 #else
 /*
 ** If SQLITE_OMIT_AUTOINCREMENT is defined, then the three routines
@@ -103431,7 +103975,7 @@ SQLITE_PRIVATE void sqlite3Insert(
     rc = sqlite3Select(pParse, pSelect, &dest);
     regFromSelect = dest.iSdst;
     if( rc || db->mallocFailed || pParse->nErr ) goto insert_cleanup;
-    sqlite3VdbeAddOp1(v, OP_EndCoroutine, regYield);
+    sqlite3VdbeEndCoroutine(v, regYield);
     sqlite3VdbeJumpHere(v, addrTop - 1);                       /* label B: */
     assert( pSelect->pEList );
     nColumn = pSelect->pEList->nExpr;
@@ -103533,7 +104077,7 @@ SQLITE_PRIVATE void sqlite3Insert(
     int nIdx;
     nIdx = sqlite3OpenTableAndIndices(pParse, pTab, OP_OpenWrite, 0, -1, 0,
                                       &iDataCur, &iIdxCur);
-    aRegIdx = sqlite3DbMallocRaw(db, sizeof(int)*(nIdx+1));
+    aRegIdx = sqlite3DbMallocRawNN(db, sizeof(int)*(nIdx+1));
     if( aRegIdx==0 ){
       goto insert_cleanup;
     }
@@ -103741,7 +104285,7 @@ SQLITE_PRIVATE void sqlite3Insert(
     {
       int isReplace;    /* Set to true if constraints may cause a replace */
       sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
-          regIns, 0, ipkColumn>=0, onError, endOfLoop, &isReplace
+          regIns, 0, ipkColumn>=0, onError, endOfLoop, &isReplace, 0
       );
       sqlite3FkCheck(pParse, pTab, 0, regIns, 0, 0);
       sqlite3CompleteInsertion(pParse, pTab, iDataCur, iIdxCur,
@@ -103823,6 +104367,59 @@ insert_cleanup:
  #undef tmask
 #endif
 
+/*
+** Meanings of bits in of pWalker->eCode for checkConstraintUnchanged()
+*/
+#define CKCNSTRNT_COLUMN   0x01    /* CHECK constraint uses a changing column */
+#define CKCNSTRNT_ROWID    0x02    /* CHECK constraint references the ROWID */
+
+/* This is the Walker callback from checkConstraintUnchanged().  Set
+** bit 0x01 of pWalker->eCode if
+** pWalker->eCode to 0 if this expression node references any of the
+** columns that are being modifed by an UPDATE statement.
+*/
+static int checkConstraintExprNode(Walker *pWalker, Expr *pExpr){
+  if( pExpr->op==TK_COLUMN ){
+    assert( pExpr->iColumn>=0 || pExpr->iColumn==-1 );
+    if( pExpr->iColumn>=0 ){
+      if( pWalker->u.aiCol[pExpr->iColumn]>=0 ){
+        pWalker->eCode |= CKCNSTRNT_COLUMN;
+      }
+    }else{
+      pWalker->eCode |= CKCNSTRNT_ROWID;
+    }
+  }
+  return WRC_Continue;
+}
+
+/*
+** pExpr is a CHECK constraint on a row that is being UPDATE-ed.  The
+** only columns that are modified by the UPDATE are those for which
+** aiChng[i]>=0, and also the ROWID is modified if chngRowid is true.
+**
+** Return true if CHECK constraint pExpr does not use any of the
+** changing columns (or the rowid if it is changing).  In other words,
+** return true if this CHECK constraint can be skipped when validating
+** the new row in the UPDATE statement.
+*/
+static int checkConstraintUnchanged(Expr *pExpr, int *aiChng, int chngRowid){
+  Walker w;
+  memset(&w, 0, sizeof(w));
+  w.eCode = 0;
+  w.xExprCallback = checkConstraintExprNode;
+  w.u.aiCol = aiChng;
+  sqlite3WalkExpr(&w, pExpr);
+  if( !chngRowid ){
+    testcase( (w.eCode & CKCNSTRNT_ROWID)!=0 );
+    w.eCode &= ~CKCNSTRNT_ROWID;
+  }
+  testcase( w.eCode==0 );
+  testcase( w.eCode==CKCNSTRNT_COLUMN );
+  testcase( w.eCode==CKCNSTRNT_ROWID );
+  testcase( w.eCode==(CKCNSTRNT_ROWID|CKCNSTRNT_COLUMN) );
+  return !w.eCode;
+}
+
 /*
 ** Generate code to do constraint checks prior to an INSERT or an UPDATE
 ** on table pTab.
@@ -103917,7 +104514,8 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
   u8 pkChng,           /* Non-zero if the rowid or PRIMARY KEY changed */
   u8 overrideError,    /* Override onError to this if not OE_Default */
   int ignoreDest,      /* Jump to this label on an OE_Ignore resolution */
-  int *pbMayReplace    /* OUT: Set to true if constraint may cause a replace */
+  int *pbMayReplace,   /* OUT: Set to true if constraint may cause a replace */
+  int *aiChng          /* column i is unchanged if aiChng[i]<0 */
 ){
   Vdbe *v;             /* VDBE under constrution */
   Index *pIdx;         /* Pointer to one of the indices */
@@ -103963,10 +104561,14 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
   */
   for(i=0; i<nCol; i++){
     if( i==pTab->iPKey ){
+      continue;        /* ROWID is never NULL */
+    }
+    if( aiChng && aiChng[i]<0 ){
+      /* Don't bother checking for NOT NULL on columns that do not change */
       continue;
     }
     onError = pTab->aCol[i].notNull;
-    if( onError==OE_None ) continue;
+    if( onError==OE_None ) continue;  /* This column is allowed to be NULL */
     if( overrideError!=OE_Default ){
       onError = overrideError;
     }else if( onError==OE_Default ){
@@ -104015,8 +104617,11 @@ SQLITE_PRIVATE void sqlite3GenerateConstraintChecks(
     pParse->ckBase = regNewData+1;
     onError = overrideError!=OE_Default ? overrideError : OE_Abort;
     for(i=0; i<pCheck->nExpr; i++){
-      int allOk = sqlite3VdbeMakeLabel(v);
-      sqlite3ExprIfTrue(pParse, pCheck->a[i].pExpr, allOk, SQLITE_JUMPIFNULL);
+      int allOk;
+      Expr *pExpr = pCheck->a[i].pExpr;
+      if( aiChng && checkConstraintUnchanged(pExpr, aiChng, pkChng) ) continue;
+      allOk = sqlite3VdbeMakeLabel(v);
+      sqlite3ExprIfTrue(pParse, pExpr, allOk, SQLITE_JUMPIFNULL);
       if( onError==OE_Ignore ){
         sqlite3VdbeGoto(v, ignoreDest);
       }else{
@@ -104366,7 +104971,7 @@ SQLITE_PRIVATE void sqlite3CompleteInsertion(
       assert( pParse->nested==0 );
       pik_flags |= OPFLAG_NCHANGE;
     }
-    if( pik_flags )  sqlite3VdbeChangeP5(v, pik_flags);
+    sqlite3VdbeChangeP5(v, pik_flags);
   }
   if( !HasRowid(pTab) ) return;
   regData = regNewData + 1;
@@ -104418,7 +105023,7 @@ SQLITE_PRIVATE int sqlite3OpenTableAndIndices(
   Parse *pParse,   /* Parsing context */
   Table *pTab,     /* Table to be opened */
   int op,          /* OP_OpenRead or OP_OpenWrite */
-  u8 p5,           /* P5 value for OP_Open* instructions */
+  u8 p5,           /* P5 value for OP_Open* opcodes (except on WITHOUT ROWID) */
   int iBase,       /* Use this for the table cursor, if there is one */
   u8 *aToOpen,     /* If not NULL: boolean for each table and index */
   int *piDataCur,  /* Write the database source cursor number here */
@@ -104453,15 +105058,16 @@ SQLITE_PRIVATE int sqlite3OpenTableAndIndices(
   for(i=0, pIdx=pTab->pIndex; pIdx; pIdx=pIdx->pNext, i++){
     int iIdxCur = iBase++;
     assert( pIdx->pSchema==pTab->pSchema );
-    if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) && piDataCur ){
-      *piDataCur = iIdxCur;
-    }
     if( aToOpen==0 || aToOpen[i+1] ){
       sqlite3VdbeAddOp3(v, op, iIdxCur, pIdx->tnum, iDb);
       sqlite3VdbeSetP4KeyInfo(pParse, pIdx);
-      sqlite3VdbeChangeP5(v, p5);
       VdbeComment((v, "%s", pIdx->zName));
     }
+    if( IsPrimaryKeyIndex(pIdx) && !HasRowid(pTab) ){
+      if( piDataCur ) *piDataCur = iIdxCur;
+    }else{
+      sqlite3VdbeChangeP5(v, p5);
+    }
   }
   if( iBase>pParse->nTab ) pParse->nTab = iBase;
   return i;
@@ -104782,9 +105388,9 @@ static int xferOptimization(
       assert( (pDest->tabFlags & TF_Autoincrement)==0 );
     }
     sqlite3VdbeAddOp2(v, OP_RowData, iSrc, regData);
-    sqlite3VdbeAddOp3(v, OP_Insert, iDest, regData, regRowid);
+    sqlite3VdbeAddOp4(v, OP_Insert, iDest, regData, regRowid,
+                      pDest->zName, 0);
     sqlite3VdbeChangeP5(v, OPFLAG_NCHANGE|OPFLAG_LASTROWID|OPFLAG_APPEND);
-    sqlite3VdbeChangeP4(v, -1, pDest->zName, 0);
     sqlite3VdbeAddOp2(v, OP_Next, iSrc, addr1); VdbeCoverage(v);
     sqlite3VdbeAddOp2(v, OP_Close, iSrc, 0);
     sqlite3VdbeAddOp2(v, OP_Close, iDest, 0);
@@ -104951,7 +105557,7 @@ SQLITE_API int SQLITE_STDCALL sqlite3_exec(
           for(i=0; i<nCol; i++){
             azVals[i] = (char *)sqlite3_column_text(pStmt, i);
             if( !azVals[i] && sqlite3_column_type(pStmt, i)!=SQLITE_NULL ){
-              db->mallocFailed = 1;
+              sqlite3OomFault(db);
               goto exec_out;
             }
           }
@@ -106839,8 +107445,8 @@ static const struct sPragmaNames {
 
 /*
 ** Interpret the given string as a safety level.  Return 0 for OFF,
-** 1 for ON or NORMAL and 2 for FULL.  Return 1 for an empty or 
-** unrecognized string argument.  The FULL option is disallowed
+** 1 for ON or NORMAL, 2 for FULL, and 3 for EXTRA.  Return 1 for an empty or 
+** unrecognized string argument.  The FULL and EXTRA option is disallowed
 ** if the omitFull parameter it 1.
 **
 ** Note that the values returned are one less that the values that
@@ -106849,18 +107455,21 @@ static const struct sPragmaNames {
 ** and older scripts may have used numbers 0 for OFF and 1 for ON.
 */
 static u8 getSafetyLevel(const char *z, int omitFull, u8 dflt){
-                             /* 123456789 123456789 */
-  static const char zText[] = "onoffalseyestruefull";
-  static const u8 iOffset[] = {0, 1, 2, 4, 9, 12, 16};
-  static const u8 iLength[] = {2, 2, 3, 5, 3, 4, 4};
-  static const u8 iValue[] =  {1, 0, 0, 0, 1, 1, 2};
+                             /* 123456789 123456789 123 */
+  static const char zText[] = "onoffalseyestruextrafull";
+  static const u8 iOffset[] = {0, 1, 2,  4,    9,  12,  15,   20};
+  static const u8 iLength[] = {2, 2, 3,  5,    3,   4,   5,    4};
+  static const u8 iValue[] =  {1, 0, 0,  0,    1,   1,   3,    2};
+                            /* on no off false yes true extra full */
   int i, n;
   if( sqlite3Isdigit(*z) ){
     return (u8)sqlite3Atoi(z);
   }
   n = sqlite3Strlen30(z);
-  for(i=0; i<ArraySize(iLength)-omitFull; i++){
-    if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0 ){
+  for(i=0; i<ArraySize(iLength); i++){
+    if( iLength[i]==n && sqlite3StrNICmp(&zText[iOffset[i]],z,n)==0
+     && (!omitFull || iValue[i]<=1)
+    ){
       return iValue[i];
     }
   }
@@ -107237,20 +107846,21 @@ SQLITE_PRIVATE void sqlite3Pragma(
       { OP_Noop,        0, 0,        0},
       { OP_ResultRow,   1, 1,        0},
     };
-    int addr;
+    VdbeOp *aOp;
     sqlite3VdbeUsesBtree(v, iDb);
     if( !zRight ){
       setOneColumnName(v, "cache_size");
       pParse->nMem += 2;
-      addr = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize,iLn);
-      sqlite3VdbeChangeP1(v, addr, iDb);
-      sqlite3VdbeChangeP1(v, addr+1, iDb);
-      sqlite3VdbeChangeP1(v, addr+6, SQLITE_DEFAULT_CACHE_SIZE);
+      sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(getCacheSize));
+      aOp = sqlite3VdbeAddOpList(v, ArraySize(getCacheSize), getCacheSize, iLn);
+      if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break;
+      aOp[0].p1 = iDb;
+      aOp[1].p1 = iDb;
+      aOp[6].p1 = SQLITE_DEFAULT_CACHE_SIZE;
     }else{
       int size = sqlite3AbsInt32(sqlite3Atoi(zRight));
       sqlite3BeginWriteOperation(pParse, 0, iDb);
-      sqlite3VdbeAddOp2(v, OP_Integer, size, 1);
-      sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, 1);
+      sqlite3VdbeAddOp3(v, OP_SetCookie, iDb, BTREE_DEFAULT_CACHE_SIZE, size);
       assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
       pDb->pSchema->cache_size = size;
       sqlite3BtreeSetCacheSize(pDb->pBt, pDb->pSchema->cache_size);
@@ -107281,7 +107891,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
       */
       db->nextPagesize = sqlite3Atoi(zRight);
       if( SQLITE_NOMEM==sqlite3BtreeSetPageSize(pBt, db->nextPagesize,-1,0) ){
-        db->mallocFailed = 1;
+        sqlite3OomFault(db);
       }
     }
     break;
@@ -107488,16 +108098,18 @@ SQLITE_PRIVATE void sqlite3Pragma(
           { OP_ReadCookie,     0,         1,         BTREE_LARGEST_ROOT_PAGE},
           { OP_If,             1,         0,                 0},    /* 2 */
           { OP_Halt,           SQLITE_OK, OE_Abort,          0},    /* 3 */
-          { OP_Integer,        0,         1,                 0},    /* 4 */
-          { OP_SetCookie,      0,         BTREE_INCR_VACUUM, 1},    /* 5 */
+          { OP_SetCookie,      0,         BTREE_INCR_VACUUM, 0},    /* 4 */
         };
-        int iAddr;
-        iAddr = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6, iLn);
-        sqlite3VdbeChangeP1(v, iAddr, iDb);
-        sqlite3VdbeChangeP1(v, iAddr+1, iDb);
-        sqlite3VdbeChangeP2(v, iAddr+2, iAddr+4);
-        sqlite3VdbeChangeP1(v, iAddr+4, eAuto-1);
-        sqlite3VdbeChangeP1(v, iAddr+5, iDb);
+        VdbeOp *aOp;
+        int iAddr = sqlite3VdbeCurrentAddr(v);
+        sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(setMeta6));
+        aOp = sqlite3VdbeAddOpList(v, ArraySize(setMeta6), setMeta6, iLn);
+        if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break;
+        aOp[0].p1 = iDb;
+        aOp[1].p1 = iDb;
+        aOp[2].p2 = iAddr+4;
+        aOp[4].p1 = iDb;
+        aOp[4].p3 = eAuto - 1;
         sqlite3VdbeUsesBtree(v, iDb);
       }
     }
@@ -107776,7 +108388,7 @@ SQLITE_PRIVATE void sqlite3Pragma(
     
   /*
   **   PRAGMA [schema.]synchronous
-  **   PRAGMA [schema.]synchronous=OFF|ON|NORMAL|FULL
+  **   PRAGMA [schema.]synchronous=OFF|ON|NORMAL|FULL|EXTRA
   **
   ** Return or set the local value of the synchronous flag.  Changing
   ** the local value does not make changes to the disk file and the
@@ -108203,18 +108815,6 @@ SQLITE_PRIVATE void sqlite3Pragma(
   case PragTyp_INTEGRITY_CHECK: {
     int i, j, addr, mxErr;
 
-    /* Code that appears at the end of the integrity check.  If no error
-    ** messages have been generated, output OK.  Otherwise output the
-    ** error message
-    */
-    static const int iLn = VDBE_OFFSET_LINENO(2);
-    static const VdbeOpList endCode[] = {
-      { OP_AddImm,      1, 0,        0},    /* 0 */
-      { OP_If,          1, 0,        0},    /* 1 */
-      { OP_String8,     0, 3,        0},    /* 2 */
-      { OP_ResultRow,   3, 1,        0},
-    };
-
     int isQuick = (sqlite3Tolower(zLeft[0])=='q');
 
     /* If the PRAGMA command was of the form "PRAGMA <db>.integrity_check",
@@ -108411,10 +109011,23 @@ SQLITE_PRIVATE void sqlite3Pragma(
 #endif /* SQLITE_OMIT_BTREECOUNT */
       } 
     }
-    addr = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode, iLn);
-    sqlite3VdbeChangeP2(v, addr, -mxErr);
-    sqlite3VdbeJumpHere(v, addr+1);
-    sqlite3VdbeChangeP4(v, addr+2, "ok", P4_STATIC);
+    {
+      static const int iLn = VDBE_OFFSET_LINENO(2);
+      static const VdbeOpList endCode[] = {
+        { OP_AddImm,      1, 0,        0},    /* 0 */
+        { OP_If,          1, 4,        0},    /* 1 */
+        { OP_String8,     0, 3,        0},    /* 2 */
+        { OP_ResultRow,   3, 1,        0},    /* 3 */
+      };
+      VdbeOp *aOp;
+
+      aOp = sqlite3VdbeAddOpList(v, ArraySize(endCode), endCode, iLn);
+      if( aOp ){
+        aOp[0].p2 = -mxErr;
+        aOp[2].p4type = P4_STATIC;
+        aOp[2].p4.z = "ok";
+      }
+    }
   }
   break;
 #endif /* SQLITE_OMIT_INTEGRITY_CHECK */
@@ -108528,14 +109141,16 @@ SQLITE_PRIVATE void sqlite3Pragma(
       /* Write the specified cookie value */
       static const VdbeOpList setCookie[] = {
         { OP_Transaction,    0,  1,  0},    /* 0 */
-        { OP_Integer,        0,  1,  0},    /* 1 */
-        { OP_SetCookie,      0,  0,  1},    /* 2 */
+        { OP_SetCookie,      0,  0,  0},    /* 1 */
       };
-      int addr = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie, 0);
-      sqlite3VdbeChangeP1(v, addr, iDb);
-      sqlite3VdbeChangeP1(v, addr+1, sqlite3Atoi(zRight));
-      sqlite3VdbeChangeP1(v, addr+2, iDb);
-      sqlite3VdbeChangeP2(v, addr+2, iCookie);
+      VdbeOp *aOp;
+      sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(setCookie));
+      aOp = sqlite3VdbeAddOpList(v, ArraySize(setCookie), setCookie, 0);
+      if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break;
+      aOp[0].p1 = iDb;
+      aOp[1].p1 = iDb;
+      aOp[1].p2 = iCookie;
+      aOp[1].p3 = sqlite3Atoi(zRight);
     }else{
       /* Read the specified cookie value */
       static const VdbeOpList readCookie[] = {
@@ -108543,10 +109158,13 @@ SQLITE_PRIVATE void sqlite3Pragma(
         { OP_ReadCookie,      0,  1,  0},    /* 1 */
         { OP_ResultRow,       1,  1,  0}
       };
-      int addr = sqlite3VdbeAddOpList(v, ArraySize(readCookie), readCookie, 0);
-      sqlite3VdbeChangeP1(v, addr, iDb);
-      sqlite3VdbeChangeP1(v, addr+1, iDb);
-      sqlite3VdbeChangeP3(v, addr+1, iCookie);
+      VdbeOp *aOp;
+      sqlite3VdbeVerifyNoMallocRequired(v, ArraySize(readCookie));
+      aOp = sqlite3VdbeAddOpList(v, ArraySize(readCookie),readCookie,0);
+      if( ONLY_IF_REALLOC_STRESS(aOp==0) ) break;
+      aOp[0].p1 = iDb;
+      aOp[1].p1 = iDb;
+      aOp[1].p3 = iCookie;
       sqlite3VdbeSetNumCols(v, 1);
       sqlite3VdbeSetColName(v, 0, COLNAME_NAME, zLeft, SQLITE_TRANSIENT);
     }
@@ -108804,11 +109422,10 @@ static void corruptSchema(
   if( !db->mallocFailed && (db->flags & SQLITE_RecoveryMode)==0 ){
     char *z;
     if( zObj==0 ) zObj = "?";
-    z = sqlite3_mprintf("malformed database schema (%s)", zObj);
-    if( z && zExtra ) z = sqlite3_mprintf("%z - %s", z, zExtra);
+    z = sqlite3MPrintf(db, "malformed database schema (%s)", zObj);
+    if( zExtra ) z = sqlite3MPrintf(db, "%z - %s", z, zExtra);
     sqlite3DbFree(db, *pData->pzErrMsg);
     *pData->pzErrMsg = z;
-    if( z==0 ) db->mallocFailed = 1;
   }
   pData->rc = db->mallocFailed ? SQLITE_NOMEM : SQLITE_CORRUPT_BKPT;
 }
@@ -108867,7 +109484,7 @@ SQLITE_PRIVATE int sqlite3InitCallback(void *pInit, int argc, char **argv, char
       }else{
         pData->rc = rc;
         if( rc==SQLITE_NOMEM ){
-          db->mallocFailed = 1;
+          sqlite3OomFault(db);
         }else if( rc!=SQLITE_INTERRUPT && (rc&0xFF)!=SQLITE_LOCKED ){
           corruptSchema(pData, argv[0], sqlite3_errmsg(db));
         }
@@ -108913,61 +109530,27 @@ static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){
 #ifndef SQLITE_OMIT_DEPRECATED
   int size;
 #endif
-  Table *pTab;
   Db *pDb;
   char const *azArg[4];
   int meta[5];
   InitData initData;
-  char const *zMasterSchema;
-  char const *zMasterName;
+  const char *zMasterName;
   int openedTransaction = 0;
 
-  /*
-  ** The master database table has a structure like this
-  */
-  static const char master_schema[] = 
-     "CREATE TABLE sqlite_master(\n"
-     "  type text,\n"
-     "  name text,\n"
-     "  tbl_name text,\n"
-     "  rootpage integer,\n"
-     "  sql text\n"
-     ")"
-  ;
-#ifndef SQLITE_OMIT_TEMPDB
-  static const char temp_master_schema[] = 
-     "CREATE TEMP TABLE sqlite_temp_master(\n"
-     "  type text,\n"
-     "  name text,\n"
-     "  tbl_name text,\n"
-     "  rootpage integer,\n"
-     "  sql text\n"
-     ")"
-  ;
-#else
-  #define temp_master_schema 0
-#endif
-
   assert( iDb>=0 && iDb<db->nDb );
   assert( db->aDb[iDb].pSchema );
   assert( sqlite3_mutex_held(db->mutex) );
   assert( iDb==1 || sqlite3BtreeHoldsMutex(db->aDb[iDb].pBt) );
 
-  /* zMasterSchema and zInitScript are set to point at the master schema
-  ** and initialisation script appropriate for the database being
-  ** initialized. zMasterName is the name of the master table.
-  */
-  if( !OMIT_TEMPDB && iDb==1 ){
-    zMasterSchema = temp_master_schema;
-  }else{
-    zMasterSchema = master_schema;
-  }
-  zMasterName = SCHEMA_TABLE(iDb);
-
-  /* Construct the schema tables.  */
-  azArg[0] = zMasterName;
+  /* Construct the in-memory representation schema tables (sqlite_master or
+  ** sqlite_temp_master) by invoking the parser directly.  The appropriate
+  ** table name will be inserted automatically by the parser so we can just
+  ** use the abbreviation "x" here.  The parser will also automatically tag
+  ** the schema table as read-only. */
+  azArg[0] = zMasterName = SCHEMA_TABLE(iDb);
   azArg[1] = "1";
-  azArg[2] = zMasterSchema;
+  azArg[2] = "CREATE TABLE x(type text,name text,tbl_name text,"
+                            "rootpage integer,sql text)";
   azArg[3] = 0;
   initData.db = db;
   initData.iDb = iDb;
@@ -108978,10 +109561,6 @@ static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){
     rc = initData.rc;
     goto error_out;
   }
-  pTab = sqlite3FindTable(db, zMasterName, db->aDb[iDb].zName);
-  if( ALWAYS(pTab) ){
-    pTab->tabFlags |= TF_Readonly;
-  }
 
   /* Create a cursor to hold the database open
   */
@@ -109100,7 +109679,7 @@ static int sqlite3InitOne(sqlite3 *db, int iDb, char **pzErrMsg){
   {
     char *zSql;
     zSql = sqlite3MPrintf(db, 
-        "SELECT name, rootpage, sql FROM '%q'.%s ORDER BY rowid",
+        "SELECT name, rootpage, sql FROM \"%w\".%s ORDER BY rowid",
         db->aDb[iDb].zName, zMasterName);
 #ifndef SQLITE_OMIT_AUTHORIZATION
     {
@@ -109150,7 +109729,7 @@ initone_error_out:
 
 error_out:
   if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
   }
   return rc;
 }
@@ -109248,7 +109827,7 @@ static void schemaIsValid(Parse *pParse){
     if( !sqlite3BtreeIsInReadTrans(pBt) ){
       rc = sqlite3BtreeBeginTrans(pBt, 0);
       if( rc==SQLITE_NOMEM || rc==SQLITE_IOERR_NOMEM ){
-        db->mallocFailed = 1;
+        sqlite3OomFault(db);
       }
       if( rc!=SQLITE_OK ) return;
       openedTransaction = 1;
@@ -109311,6 +109890,11 @@ SQLITE_PRIVATE void sqlite3ParserReset(Parse *pParse){
     sqlite3 *db = pParse->db;
     sqlite3DbFree(db, pParse->aLabel);
     sqlite3ExprListDelete(db, pParse->pConstExpr);
+    if( db ){
+      assert( db->lookaside.bDisable >= pParse->disableLookaside );
+      db->lookaside.bDisable -= pParse->disableLookaside;
+    }
+    pParse->disableLookaside = 0;
   }
 }
 
@@ -109339,7 +109923,7 @@ static int sqlite3Prepare(
   }
   pParse->pReprepare = pReprepare;
   assert( ppStmt && *ppStmt==0 );
-  assert( !db->mallocFailed );
+  /* assert( !db->mallocFailed ); // not true with SQLITE_USE_ALLOCA */
   assert( sqlite3_mutex_held(db->mutex) );
 
   /* Check to verify that it is possible to get a read lock on all
@@ -109396,8 +109980,8 @@ static int sqlite3Prepare(
     zSqlCopy = sqlite3DbStrNDup(db, zSql, nBytes);
     if( zSqlCopy ){
       sqlite3RunParser(pParse, zSqlCopy, &zErrMsg);
-      sqlite3DbFree(db, zSqlCopy);
       pParse->zTail = &zSql[pParse->zTail-zSqlCopy];
+      sqlite3DbFree(db, zSqlCopy);
     }else{
       pParse->zTail = &zSql[nBytes];
     }
@@ -109406,9 +109990,6 @@ static int sqlite3Prepare(
   }
   assert( 0==pParse->nQueryLoop );
 
-  if( db->mallocFailed ){
-    pParse->rc = SQLITE_NOMEM;
-  }
   if( pParse->rc==SQLITE_DONE ) pParse->rc = SQLITE_OK;
   if( pParse->checkSchema ){
     schemaIsValid(pParse);
@@ -109530,7 +110111,7 @@ SQLITE_PRIVATE int sqlite3Reprepare(Vdbe *p){
   rc = sqlite3LockAndPrepare(db, zSql, -1, 0, p, &pNew, 0);
   if( rc ){
     if( rc==SQLITE_NOMEM ){
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
     }
     assert( pNew==0 );
     return rc;
@@ -109784,29 +110365,37 @@ SQLITE_PRIVATE Select *sqlite3SelectNew(
   Select *pNew;
   Select standin;
   sqlite3 *db = pParse->db;
-  pNew = sqlite3DbMallocZero(db, sizeof(*pNew) );
+  pNew = sqlite3DbMallocRawNN(db, sizeof(*pNew) );
   if( pNew==0 ){
     assert( db->mallocFailed );
     pNew = &standin;
-    memset(pNew, 0, sizeof(*pNew));
   }
   if( pEList==0 ){
     pEList = sqlite3ExprListAppend(pParse, 0, sqlite3Expr(db,TK_ASTERISK,0));
   }
   pNew->pEList = pEList;
+  pNew->op = TK_SELECT;
+  pNew->selFlags = selFlags;
+  pNew->iLimit = 0;
+  pNew->iOffset = 0;
+#if SELECTTRACE_ENABLED
+  pNew->zSelName[0] = 0;
+#endif
+  pNew->addrOpenEphm[0] = -1;
+  pNew->addrOpenEphm[1] = -1;
+  pNew->nSelectRow = 0;
   if( pSrc==0 ) pSrc = sqlite3DbMallocZero(db, sizeof(*pSrc));
   pNew->pSrc = pSrc;
   pNew->pWhere = pWhere;
   pNew->pGroupBy = pGroupBy;
   pNew->pHaving = pHaving;
   pNew->pOrderBy = pOrderBy;
-  pNew->selFlags = selFlags;
-  pNew->op = TK_SELECT;
+  pNew->pPrior = 0;
+  pNew->pNext = 0;
   pNew->pLimit = pLimit;
   pNew->pOffset = pOffset;
+  pNew->pWith = 0;
   assert( pOffset==0 || pLimit!=0 || pParse->nErr>0 || db->mallocFailed!=0 );
-  pNew->addrOpenEphm[0] = -1;
-  pNew->addrOpenEphm[1] = -1;
   if( db->mallocFailed ) {
     clearSelect(db, pNew, pNew!=&standin);
     pNew = 0;
@@ -110669,8 +111258,8 @@ static void selectInnerLoop(
 ** X extra columns.
 */
 SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N, int X){
-  KeyInfo *p = sqlite3DbMallocZero(0, 
-                   sizeof(KeyInfo) + (N+X)*(sizeof(CollSeq*)+1));
+  int nExtra = (N+X)*(sizeof(CollSeq*)+1);
+  KeyInfo *p = sqlite3Malloc(sizeof(KeyInfo) + nExtra);
   if( p ){
     p->aSortOrder = (u8*)&p->aColl[N+X];
     p->nField = (u16)N;
@@ -110678,8 +111267,9 @@ SQLITE_PRIVATE KeyInfo *sqlite3KeyInfoAlloc(sqlite3 *db, int N, int X){
     p->enc = ENC(db);
     p->db = db;
     p->nRef = 1;
+    memset(&p[1], 0, nExtra);
   }else{
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
   }
   return p;
 }
@@ -111340,7 +111930,7 @@ SQLITE_PRIVATE int sqlite3ColumnsFromExprList(
     pCol->zName = zName;
     sqlite3ColumnPropertiesFromName(0, pCol);
     if( zName && sqlite3HashInsert(&ht, zName, pCol)==pCol ){
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
     }
   }
   sqlite3HashClear(&ht);
@@ -111427,7 +112017,7 @@ SQLITE_PRIVATE Table *sqlite3ResultSetOfSelect(Parse *pParse, Select *pSelect){
   }
   /* The sqlite3ResultSetOfSelect() is only used n contexts where lookaside
   ** is disabled */
-  assert( db->lookaside.bEnabled==0 );
+  assert( db->lookaside.bDisable );
   pTab->nRef = 1;
   pTab->zName = 0;
   pTab->nRowLogEst = 200; assert( 200==sqlite3LogEst(1048576) );
@@ -111523,10 +112113,8 @@ static void computeLimitRegisters(Parse *pParse, Select *p, int iBreak){
       sqlite3ExprCode(pParse, p->pOffset, iOffset);
       sqlite3VdbeAddOp1(v, OP_MustBeInt, iOffset); VdbeCoverage(v);
       VdbeComment((v, "OFFSET counter"));
-      sqlite3VdbeAddOp3(v, OP_SetIfNotPos, iOffset, iOffset, 0);
-      sqlite3VdbeAddOp3(v, OP_Add, iLimit, iOffset, iOffset+1);
+      sqlite3VdbeAddOp3(v, OP_OffsetLimit, iLimit, iOffset+1, iOffset);
       VdbeComment((v, "LIMIT+OFFSET"));
-      sqlite3VdbeAddOp3(v, OP_SetIfNotPos, iLimit, iOffset+1, -1);
     }
   }
 }
@@ -111943,9 +112531,8 @@ static int multiSelect(
         addr = sqlite3VdbeAddOp1(v, OP_IfNot, p->iLimit); VdbeCoverage(v);
         VdbeComment((v, "Jump ahead if LIMIT reached"));
         if( p->iOffset ){
-          sqlite3VdbeAddOp3(v, OP_SetIfNotPos, p->iOffset, p->iOffset, 0);
-          sqlite3VdbeAddOp3(v, OP_Add, p->iLimit, p->iOffset, p->iOffset+1);
-          sqlite3VdbeAddOp3(v, OP_SetIfNotPos, p->iLimit, p->iOffset+1, -1);
+          sqlite3VdbeAddOp3(v, OP_OffsetLimit,
+                            p->iLimit, p->iOffset+1, p->iOffset);
         }
       }
       explainSetInteger(iSub2, pParse->iNextSelectId);
@@ -112536,10 +113123,11 @@ static int multiSelectOrderBy(
   ** to the right and the left are evaluated, they use the correct
   ** collation.
   */
-  aPermute = sqlite3DbMallocRaw(db, sizeof(int)*nOrderBy);
+  aPermute = sqlite3DbMallocRawNN(db, sizeof(int)*(nOrderBy + 1));
   if( aPermute ){
     struct ExprList_item *pItem;
-    for(i=0, pItem=pOrderBy->a; i<nOrderBy; i++, pItem++){
+    aPermute[0] = nOrderBy;
+    for(i=1, pItem=pOrderBy->a; i<=nOrderBy; i++, pItem++){
       assert( pItem->u.x.iOrderByCol>0 );
       assert( pItem->u.x.iOrderByCol<=p->pEList->nExpr );
       aPermute[i] = pItem->u.x.iOrderByCol - 1;
@@ -112617,7 +113205,7 @@ static int multiSelectOrderBy(
   pPrior->iLimit = regLimitA;
   explainSetInteger(iSub1, pParse->iNextSelectId);
   sqlite3Select(pParse, pPrior, &destA);
-  sqlite3VdbeAddOp1(v, OP_EndCoroutine, regAddrA);
+  sqlite3VdbeEndCoroutine(v, regAddrA);
   sqlite3VdbeJumpHere(v, addr1);
 
   /* Generate a coroutine to evaluate the SELECT statement on 
@@ -112634,7 +113222,7 @@ static int multiSelectOrderBy(
   sqlite3Select(pParse, p, &destB);
   p->iLimit = savedLimit;
   p->iOffset = savedOffset;
-  sqlite3VdbeAddOp1(v, OP_EndCoroutine, regAddrB);
+  sqlite3VdbeEndCoroutine(v, regAddrB);
 
   /* Generate a subroutine that outputs the current row of the A
   ** select as the next output row of the compound select.
@@ -114101,8 +114689,7 @@ static int selectExpander(Walker *pWalker, Select *p){
               pExpr = pRight;
             }
             pNew = sqlite3ExprListAppend(pParse, pNew, pExpr);
-            sColname.z = zColname;
-            sColname.n = sqlite3Strlen30(zColname);
+            sqlite3TokenInit(&sColname, zColname);
             sqlite3ExprListSetName(pParse, pNew, &sColname, 0);
             if( pNew && (p->selFlags & SF_NestedFrom)!=0 ){
               struct ExprList_item *pX = &pNew->a[pNew->nExpr-1];
@@ -114656,7 +115243,7 @@ SQLITE_PRIVATE int sqlite3Select(
       pItem->pTab->nRowLogEst = sqlite3LogEst(pSub->nSelectRow);
       pItem->fg.viaCoroutine = 1;
       pItem->regResult = dest.iSdst;
-      sqlite3VdbeAddOp1(v, OP_EndCoroutine, pItem->regReturn);
+      sqlite3VdbeEndCoroutine(v, pItem->regReturn);
       sqlite3VdbeJumpHere(v, addrTop-1);
       sqlite3ClearTempRegCache(pParse);
     }else{
@@ -115228,7 +115815,8 @@ SQLITE_PRIVATE int sqlite3Select(
         if( flag ){
           pMinMax = sqlite3ExprListDup(db, pMinMax, 0);
           pDel = pMinMax;
-          if( pMinMax && !db->mallocFailed ){
+          assert( db->mallocFailed || pMinMax!=0 );
+          if( !db->mallocFailed ){
             pMinMax->a[0].sortOrder = flag!=WHERE_ORDERBY_MIN ?1:0;
             pMinMax->a[0].pExpr->op = TK_COLUMN;
           }
@@ -115801,8 +116389,7 @@ SQLITE_PRIVATE void sqlite3FinishTrigger(
     pStepList->pTrig = pTrig;
     pStepList = pStepList->pNext;
   }
-  nameToken.z = pTrig->zName;
-  nameToken.n = sqlite3Strlen30(nameToken.z);
+  sqlite3TokenInit(&nameToken, pTrig->zName);
   sqlite3FixInit(&sFix, pParse, iDb, "trigger", &nameToken);
   if( sqlite3FixTriggerStep(&sFix, pTrig->step_list) 
    || sqlite3FixExpr(&sFix, pTrig->pWhen) 
@@ -115838,7 +116425,7 @@ SQLITE_PRIVATE void sqlite3FinishTrigger(
     assert( sqlite3SchemaMutexHeld(db, iDb, 0) );
     pTrig = sqlite3HashInsert(pHash, zName, pTrig);
     if( pTrig ){
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
     }else if( pLink->pSchema==pLink->pTabSchema ){
       Table *pTab;
       pTab = sqlite3HashFind(&pLink->pTabSchema->tblHash, pLink->table);
@@ -116466,8 +117053,8 @@ SQLITE_PRIVATE void sqlite3CodeRowTriggerDirect(
   if( pPrg ){
     int bRecursive = (p->zName && 0==(pParse->db->flags&SQLITE_RecTriggers));
 
-    sqlite3VdbeAddOp3(v, OP_Program, reg, ignoreJump, ++pParse->nMem);
-    sqlite3VdbeChangeP4(v, -1, (const char *)pPrg->pProgram, P4_SUBPROGRAM);
+    sqlite3VdbeAddOp4(v, OP_Program, reg, ignoreJump, ++pParse->nMem,
+                      (const char *)pPrg->pProgram, P4_SUBPROGRAM);
     VdbeComment(
         (v, "Call: %s.%s", (p->zName?p->zName:"fkey"), onErrorText(orconf)));
 
@@ -116814,7 +117401,7 @@ SQLITE_PRIVATE void sqlite3Update(
   /* Allocate space for aXRef[], aRegIdx[], and aToOpen[].  
   ** Initialize aXRef[] and aToOpen[] to their default values.
   */
-  aXRef = sqlite3DbMallocRaw(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 );
+  aXRef = sqlite3DbMallocRawNN(db, sizeof(int) * (pTab->nCol+nIdx) + nIdx+2 );
   if( aXRef==0 ) goto update_cleanup;
   aRegIdx = aXRef+pTab->nCol;
   aToOpen = (u8*)(aRegIdx+nIdx);
@@ -117189,7 +117776,8 @@ SQLITE_PRIVATE void sqlite3Update(
     /* Do constraint checks. */
     assert( regOldRowid>0 );
     sqlite3GenerateConstraintChecks(pParse, pTab, aRegIdx, iDataCur, iIdxCur,
-        regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace);
+        regNewRowid, regOldRowid, chngKey, onError, labelContinue, &bReplace,
+        aXRef);
 
     /* Do FK constraint checks. */
     if( hasFK ){
@@ -117854,7 +118442,7 @@ static int createModule(
     rc = SQLITE_MISUSE_BKPT;
   }else{
     Module *pMod;
-    pMod = (Module *)sqlite3DbMallocRaw(db, sizeof(Module) + nName + 1);
+    pMod = (Module *)sqlite3DbMallocRawNN(db, sizeof(Module) + nName + 1);
     if( pMod ){
       Module *pDel;
       char *zCopy = (char *)(&pMod[1]);
@@ -117867,7 +118455,7 @@ static int createModule(
       pDel = (Module *)sqlite3HashInsert(&db->aModule,zCopy,(void*)pMod);
       assert( pDel==0 || pDel==pMod );
       if( pDel ){
-        db->mallocFailed = 1;
+        sqlite3OomFault(db);
         sqlite3DbFree(db, pDel);
       }
     }
@@ -118244,7 +118832,7 @@ SQLITE_PRIVATE void sqlite3VtabFinishParse(Parse *pParse, Token *pEnd){
     assert( sqlite3SchemaMutexHeld(db, 0, pSchema) );
     pOld = sqlite3HashInsert(&pSchema->tblHash, zName, pTab);
     if( pOld ){
-      db->mallocFailed = 1;
+      sqlite3OomFault(db);
       assert( pTab==pOld );  /* Malloc must have failed inside HashInsert() */
       return;
     }
@@ -118335,7 +118923,7 @@ static int vtabCallConstructor(
   db->pVtabCtx = &sCtx;
   rc = xConstruct(db, pMod->pAux, nArg, azArg, &pVTable->pVtab, &zErr);
   db->pVtabCtx = sCtx.pPrior;
-  if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;
+  if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
   assert( sCtx.pTab==pTab );
 
   if( SQLITE_OK!=rc ){
@@ -118821,7 +119409,7 @@ SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction(
   Table *pTab;
   sqlite3_vtab *pVtab;
   sqlite3_module *pMod;
-  void (*xFunc)(sqlite3_context*,int,sqlite3_value**) = 0;
+  void (*xSFunc)(sqlite3_context*,int,sqlite3_value**) = 0;
   void *pArg = 0;
   FuncDef *pNew;
   int rc = 0;
@@ -118849,7 +119437,7 @@ SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction(
     for(z=(unsigned char*)zLowerName; *z; z++){
       *z = sqlite3UpperToLower[*z];
     }
-    rc = pMod->xFindFunction(pVtab, nArg, zLowerName, &xFunc, &pArg);
+    rc = pMod->xFindFunction(pVtab, nArg, zLowerName, &xSFunc, &pArg);
     sqlite3DbFree(db, zLowerName);
   }
   if( rc==0 ){
@@ -118866,7 +119454,7 @@ SQLITE_PRIVATE FuncDef *sqlite3VtabOverloadFunction(
   *pNew = *pDef;
   pNew->zName = (char *)&pNew[1];
   memcpy(pNew->zName, pDef->zName, sqlite3Strlen30(pDef->zName)+1);
-  pNew->xFunc = xFunc;
+  pNew->xSFunc = xSFunc;
   pNew->pUserData = pArg;
   pNew->funcFlags |= SQLITE_FUNC_EPHEM;
   return pNew;
@@ -118893,7 +119481,7 @@ SQLITE_PRIVATE void sqlite3VtabMakeWritable(Parse *pParse, Table *pTab){
     pToplevel->apVtabLock = apVtabLock;
     pToplevel->apVtabLock[pToplevel->nVtabLock++] = pTab;
   }else{
-    pToplevel->db->mallocFailed = 1;
+    sqlite3OomFault(pToplevel->db);
   }
 }
 
@@ -119635,7 +120223,7 @@ static void explainIndexRange(StrAccum *pStr, WhereLoop *pLoop){
   for(i=0; i<nEq; i++){
     const char *z = explainIndexColumnName(pIndex, i);
     if( i ) sqlite3StrAccumAppend(pStr, " AND ", 5);
-    sqlite3XPrintf(pStr, 0, i>=nSkip ? "%s=?" : "ANY(%s)", z);
+    sqlite3XPrintf(pStr, i>=nSkip ? "%s=?" : "ANY(%s)", z);
   }
 
   j = i;
@@ -119694,13 +120282,13 @@ SQLITE_PRIVATE int sqlite3WhereExplainOneScan(
     sqlite3StrAccumInit(&str, db, zBuf, sizeof(zBuf), SQLITE_MAX_LENGTH);
     sqlite3StrAccumAppendAll(&str, isSearch ? "SEARCH" : "SCAN");
     if( pItem->pSelect ){
-      sqlite3XPrintf(&str, 0, " SUBQUERY %d", pItem->iSelectId);
+      sqlite3XPrintf(&str, " SUBQUERY %d", pItem->iSelectId);
     }else{
-      sqlite3XPrintf(&str, 0, " TABLE %s", pItem->zName);
+      sqlite3XPrintf(&str, " TABLE %s", pItem->zName);
     }
 
     if( pItem->zAlias ){
-      sqlite3XPrintf(&str, 0, " AS %s", pItem->zAlias);
+      sqlite3XPrintf(&str, " AS %s", pItem->zAlias);
     }
     if( (flags & (WHERE_IPK|WHERE_VIRTUALTABLE))==0 ){
       const char *zFmt = 0;
@@ -119724,7 +120312,7 @@ SQLITE_PRIVATE int sqlite3WhereExplainOneScan(
       }
       if( zFmt ){
         sqlite3StrAccumAppend(&str, " USING ", 7);
-        sqlite3XPrintf(&str, 0, zFmt, pIdx->zName);
+        sqlite3XPrintf(&str, zFmt, pIdx->zName);
         explainIndexRange(&str, pLoop);
       }
     }else if( (flags & WHERE_IPK)!=0 && (flags & WHERE_CONSTRAINT)!=0 ){
@@ -119739,17 +120327,17 @@ SQLITE_PRIVATE int sqlite3WhereExplainOneScan(
         assert( flags&WHERE_TOP_LIMIT);
         zRangeOp = "<";
       }
-      sqlite3XPrintf(&str, 0, " USING INTEGER PRIMARY KEY (rowid%s?)",zRangeOp);
+      sqlite3XPrintf(&str, " USING INTEGER PRIMARY KEY (rowid%s?)",zRangeOp);
     }
 #ifndef SQLITE_OMIT_VIRTUALTABLE
     else if( (flags & WHERE_VIRTUALTABLE)!=0 ){
-      sqlite3XPrintf(&str, 0, " VIRTUAL TABLE INDEX %d:%s",
+      sqlite3XPrintf(&str, " VIRTUAL TABLE INDEX %d:%s",
                   pLoop->u.vtab.idxNum, pLoop->u.vtab.idxStr);
     }
 #endif
 #ifdef SQLITE_EXPLAIN_ESTIMATED_ROWS
     if( pLoop->nOut>=10 ){
-      sqlite3XPrintf(&str, 0, " (~%llu rows)", sqlite3LogEstToInt(pLoop->nOut));
+      sqlite3XPrintf(&str, " (~%llu rows)", sqlite3LogEstToInt(pLoop->nOut));
     }else{
       sqlite3StrAccumAppend(&str, " (~1 row)", 9);
     }
@@ -119886,8 +120474,7 @@ static void codeApplyAffinity(Parse *pParse, int base, int n, char *zAff){
 
   /* Code the OP_Affinity opcode if there is anything left to do. */
   if( n>0 ){
-    sqlite3VdbeAddOp2(v, OP_Affinity, base, n);
-    sqlite3VdbeChangeP4(v, -1, zAff, n);
+    sqlite3VdbeAddOp4(v, OP_Affinity, base, n, 0, zAff, n);
     sqlite3ExprCacheAffinityChange(pParse, base, n);
   }
 }
@@ -120055,9 +120642,7 @@ static int codeAllEqualityTerms(
   pParse->nMem += nReg;
 
   zAff = sqlite3DbStrDup(pParse->db,sqlite3IndexAffinityStr(pParse->db,pIdx));
-  if( !zAff ){
-    pParse->db->mallocFailed = 1;
-  }
+  assert( zAff!=0 || pParse->db->mallocFailed );
 
   if( nSkip ){
     int iIdxCur = pLevel->iIdxCur;
@@ -120306,6 +120891,54 @@ static void codeCursorHint(
 # define codeCursorHint(A,B,C)  /* No-op */
 #endif /* SQLITE_ENABLE_CURSOR_HINTS */
 
+/*
+** Cursor iCur is open on an intkey b-tree (a table). Register iRowid contains
+** a rowid value just read from cursor iIdxCur, open on index pIdx. This
+** function generates code to do a deferred seek of cursor iCur to the 
+** rowid stored in register iRowid.
+**
+** Normally, this is just:
+**
+**   OP_Seek $iCur $iRowid
+**
+** However, if the scan currently being coded is a branch of an OR-loop and
+** the statement currently being coded is a SELECT, then P3 of the OP_Seek
+** is set to iIdxCur and P4 is set to point to an array of integers
+** containing one entry for each column of the table cursor iCur is open 
+** on. For each table column, if the column is the i'th column of the 
+** index, then the corresponding array entry is set to (i+1). If the column
+** does not appear in the index at all, the array entry is set to 0.
+*/
+static void codeDeferredSeek(
+  WhereInfo *pWInfo,              /* Where clause context */
+  Index *pIdx,                    /* Index scan is using */
+  int iCur,                       /* Cursor for IPK b-tree */
+  int iIdxCur                     /* Index cursor */
+){
+  Parse *pParse = pWInfo->pParse; /* Parse context */
+  Vdbe *v = pParse->pVdbe;        /* Vdbe to generate code within */
+
+  assert( iIdxCur>0 );
+  assert( pIdx->aiColumn[pIdx->nColumn-1]==-1 );
+  
+  sqlite3VdbeAddOp3(v, OP_Seek, iIdxCur, 0, iCur);
+  if( (pWInfo->wctrlFlags & WHERE_FORCE_TABLE)
+   && DbMaskAllZero(sqlite3ParseToplevel(pParse)->writeMask)
+  ){
+    int i;
+    Table *pTab = pIdx->pTable;
+    int *ai = (int*)sqlite3DbMallocZero(pParse->db, sizeof(int)*(pTab->nCol+1));
+    if( ai ){
+      ai[0] = pTab->nCol;
+      for(i=0; i<pIdx->nColumn-1; i++){
+        assert( pIdx->aiColumn[i]<pTab->nCol );
+        if( pIdx->aiColumn[i]>=0 ) ai[pIdx->aiColumn[i]+1] = i+1;
+      }
+      sqlite3VdbeChangeP4(v, -1, (char*)ai, P4_INTARRAY);
+    }
+  }
+}
+
 /*
 ** Generate code for the start of the iLevel-th loop in the WHERE clause
 ** implementation described by pWInfo.
@@ -120785,14 +121418,14 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
     if( omitTable ){
       /* pIdx is a covering index.  No need to access the main table. */
     }else if( HasRowid(pIdx->pTable) ){
-      iRowidReg = ++pParse->nMem;
-      sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, iRowidReg);
-      sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg);
       if( pWInfo->eOnePass!=ONEPASS_OFF ){
+        iRowidReg = ++pParse->nMem;
+        sqlite3VdbeAddOp2(v, OP_IdxRowid, iIdxCur, iRowidReg);
+        sqlite3ExprCacheStore(pParse, iCur, -1, iRowidReg);
         sqlite3VdbeAddOp3(v, OP_NotExists, iCur, 0, iRowidReg);
         VdbeCoverage(v);
       }else{
-        sqlite3VdbeAddOp2(v, OP_Seek, iCur, iRowidReg);  /* Deferred seek */
+        codeDeferredSeek(pWInfo, pIdx, iCur, iIdxCur);
       }
     }else if( iCur!=iIdxCur ){
       Index *pPk = sqlite3PrimaryKeyIndex(pIdx->pTable);
@@ -120961,7 +121594,9 @@ SQLITE_PRIVATE Bitmask sqlite3WhereCodeOneLoopStart(
         Expr *pExpr = pWC->a[iTerm].pExpr;
         if( &pWC->a[iTerm] == pTerm ) continue;
         if( ExprHasProperty(pExpr, EP_FromJoin) ) continue;
-        if( (pWC->a[iTerm].wtFlags & TERM_VIRTUAL)!=0 ) continue;
+        testcase( pWC->a[iTerm].wtFlags & TERM_VIRTUAL );
+        testcase( pWC->a[iTerm].wtFlags & TERM_CODED );
+        if( (pWC->a[iTerm].wtFlags & (TERM_VIRTUAL|TERM_CODED))!=0 ) continue;
         if( (pWC->a[iTerm].eOperator & WO_ALL)==0 ) continue;
         testcase( pWC->a[iTerm].wtFlags & TERM_ORINFO );
         pExpr = sqlite3ExprDup(db, pExpr, 0);
@@ -121301,7 +121936,7 @@ static int whereClauseInsert(WhereClause *pWC, Expr *p, u16 wtFlags){
   if( pWC->nTerm>=pWC->nSlot ){
     WhereTerm *pOld = pWC->a;
     sqlite3 *db = pWC->pWInfo->pParse->db;
-    pWC->a = sqlite3DbMallocRaw(db, sizeof(pWC->a[0])*pWC->nSlot*2 );
+    pWC->a = sqlite3DbMallocRawNN(db, sizeof(pWC->a[0])*pWC->nSlot*2 );
     if( pWC->a==0 ){
       if( wtFlags & TERM_DYNAMIC ){
         sqlite3ExprDelete(db, p);
@@ -121439,6 +122074,7 @@ static int isLikeOrGlob(
   sqlite3 *db = pParse->db;  /* Database connection */
   sqlite3_value *pVal = 0;
   int op;                    /* Opcode of pRight */
+  int rc;                    /* Result code to return */
 
   if( !sqlite3IsLikeFunction(db, pExpr, pnoCase, wc) ){
     return 0;
@@ -121504,8 +122140,9 @@ static int isLikeOrGlob(
     }
   }
 
+  rc = (z!=0);
   sqlite3ValueFree(pVal);
-  return (z!=0);
+  return rc;
 }
 #endif /* SQLITE_OMIT_LIKE_OPTIMIZATION */
 
@@ -121784,7 +122421,7 @@ static void exprAnalyzeOrTerm(
       WhereAndInfo *pAndInfo;
       assert( (pOrTerm->wtFlags & (TERM_ANDINFO|TERM_ORINFO))==0 );
       chngToIN = 0;
-      pAndInfo = sqlite3DbMallocRaw(db, sizeof(*pAndInfo));
+      pAndInfo = sqlite3DbMallocRawNN(db, sizeof(*pAndInfo));
       if( pAndInfo ){
         WhereClause *pAndWC;
         WhereTerm *pAndTerm;
@@ -121798,7 +122435,6 @@ static void exprAnalyzeOrTerm(
         sqlite3WhereSplit(pAndWC, pOrTerm->pExpr, TK_AND);
         sqlite3WhereExprAnalyze(pSrc, pAndWC);
         pAndWC->pOuter = pWC;
-        testcase( db->mallocFailed );
         if( !db->mallocFailed ){
           for(j=0, pAndTerm=pAndWC->a; j<pAndWC->nTerm; j++, pAndTerm++){
             assert( pAndTerm->pExpr );
@@ -123541,7 +124177,7 @@ static int vtabBestIndex(Parse *pParse, Table *pTab, sqlite3_index_info *p){
 
   if( rc!=SQLITE_OK ){
     if( rc==SQLITE_NOMEM ){
-      pParse->db->mallocFailed = 1;
+      sqlite3OomFault(pParse->db);
     }else if( !pVtab->zErrMsg ){
       sqlite3ErrorMsg(pParse, "%s", sqlite3ErrStr(rc));
     }else{
@@ -124333,7 +124969,7 @@ static int whereLoopResize(sqlite3 *db, WhereLoop *p, int n){
   WhereTerm **paNew;
   if( p->nLSlot>=n ) return SQLITE_OK;
   n = (n+7)&~7;
-  paNew = sqlite3DbMallocRaw(db, sizeof(p->aLTerm[0])*n);
+  paNew = sqlite3DbMallocRawNN(db, sizeof(p->aLTerm[0])*n);
   if( paNew==0 ) return SQLITE_NOMEM;
   memcpy(paNew, p->aLTerm, sizeof(p->aLTerm[0])*p->nLSlot);
   if( p->aLTerm!=p->aLTermSpace ) sqlite3DbFree(db, p->aLTerm);
@@ -124630,7 +125266,7 @@ static int whereLoopInsert(WhereLoopBuilder *pBuilder, WhereLoop *pTemplate){
 #endif
   if( p==0 ){
     /* Allocate a new WhereLoop to add to the end of the list */
-    *ppPrev = p = sqlite3DbMallocRaw(db, sizeof(WhereLoop));
+    *ppPrev = p = sqlite3DbMallocRawNN(db, sizeof(WhereLoop));
     if( p==0 ) return SQLITE_NOMEM;
     whereLoopInit(p);
     p->pNextLoop = 0;
@@ -126036,7 +126672,6 @@ static const char *wherePathName(WherePath *pPath, int nLoop, WhereLoop *pLast){
 ** order.
 */
 static LogEst whereSortingCost(
-  WhereInfo *pWInfo,
   LogEst nRow,
   int nOrderBy,
   int nSorted
@@ -126058,14 +126693,6 @@ static LogEst whereSortingCost(
   assert( nOrderBy>0 && 66==sqlite3LogEst(100) );
   rScale = sqlite3LogEst((nOrderBy-nSorted)*100/nOrderBy) - 66;
   rSortCost = nRow + estLog(nRow) + rScale + 16;
-
-  /* TUNING: The cost of implementing DISTINCT using a B-TREE is
-  ** similar but with a larger constant of proportionality. 
-  ** Multiply by an additional factor of 3.0.  */
-  if( pWInfo->wctrlFlags & WHERE_WANT_DISTINCT ){
-    rSortCost += 16;
-  }
-
   return rSortCost;
 }
 
@@ -126127,7 +126754,7 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){
   /* Allocate and initialize space for aTo, aFrom and aSortCost[] */
   nSpace = (sizeof(WherePath)+sizeof(WhereLoop*)*nLoop)*mxChoice*2;
   nSpace += sizeof(LogEst) * nOrderBy;
-  pSpace = sqlite3DbMallocRaw(db, nSpace);
+  pSpace = sqlite3DbMallocRawNN(db, nSpace);
   if( pSpace==0 ) return SQLITE_NOMEM;
   aTo = (WherePath*)pSpace;
   aFrom = aTo+mxChoice;
@@ -126199,7 +126826,7 @@ static int wherePathSolver(WhereInfo *pWInfo, LogEst nRowEst){
         if( isOrdered>=0 && isOrdered<nOrderBy ){
           if( aSortCost[isOrdered]==0 ){
             aSortCost[isOrdered] = whereSortingCost(
-                pWInfo, nRowEst, nOrderBy, isOrdered
+                nRowEst, nOrderBy, isOrdered
             );
           }
           rCost = sqlite3LogEstAdd(rUnsorted, aSortCost[isOrdered]);
@@ -126612,7 +127239,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
   int ii;                    /* Loop counter */
   sqlite3 *db;               /* Database connection */
   int rc;                    /* Return code */
-  u8 bFordelete = 0;
+  u8 bFordelete = 0;         /* OPFLAG_FORDELETE or zero, as appropriate */
 
   assert( (wctrlFlags & WHERE_ONEPASS_MULTIROW)==0 || (
         (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0 
@@ -126857,16 +127484,15 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
 
   /* If the caller is an UPDATE or DELETE statement that is requesting
   ** to use a one-pass algorithm, determine if this is appropriate.
-  ** The one-pass algorithm only works if the WHERE clause constrains
-  ** the statement to update or delete a single row.
   */
   assert( (wctrlFlags & WHERE_ONEPASS_DESIRED)==0 || pWInfo->nLevel==1 );
   if( (wctrlFlags & WHERE_ONEPASS_DESIRED)!=0 ){
     int wsFlags = pWInfo->a[0].pWLoop->wsFlags;
     int bOnerow = (wsFlags & WHERE_ONEROW)!=0;
-    if( bOnerow || ( (wctrlFlags & WHERE_ONEPASS_MULTIROW)
-       && 0==(wsFlags & WHERE_VIRTUALTABLE)
-    )){
+    if( bOnerow
+     || ((wctrlFlags & WHERE_ONEPASS_MULTIROW)!=0
+           && 0==(wsFlags & WHERE_VIRTUALTABLE))
+    ){
       pWInfo->eOnePass = bOnerow ? ONEPASS_SINGLE : ONEPASS_MULTI;
       if( HasRowid(pTabList->a[0].pTab) && (wsFlags & WHERE_IDX_ONLY) ){
         if( wctrlFlags & WHERE_ONEPASS_MULTIROW ){
@@ -126916,8 +127542,7 @@ SQLITE_PRIVATE WhereInfo *sqlite3WhereBegin(
         Bitmask b = pTabItem->colUsed;
         int n = 0;
         for(; b; b=b>>1, n++){}
-        sqlite3VdbeChangeP4(v, sqlite3VdbeCurrentAddr(v)-1, 
-                            SQLITE_INT_TO_PTR(n), P4_INT32);
+        sqlite3VdbeChangeP4(v, -1, SQLITE_INT_TO_PTR(n), P4_INT32);
         assert( n<=pTab->nCol );
       }
 #ifdef SQLITE_ENABLE_CURSOR_HINTS
@@ -127311,6 +127936,15 @@ struct TrigEvent { int a; IdList * b; };
 */
 struct AttachKey { int type;  Token key; };
 
+/*
+** Disable lookaside memory allocation for objects that might be
+** shared across database connections.
+*/
+static void disableLookaside(Parse *pParse){
+  pParse->disableLookaside++;
+  pParse->db->lookaside.bDisable++;
+}
+
 
   /*
   ** For a compound SELECT statement, make sure p->pPrior->pNext==p for
@@ -127393,7 +128027,7 @@ struct AttachKey { int type;  Token key; };
   ** unary TK_ISNULL or TK_NOTNULL expression. */
   static void binaryToUnaryIfNull(Parse *pParse, Expr *pY, Expr *pA, int op){
     sqlite3 *db = pParse->db;
-    if( pY && pA && pY->op==TK_NULL ){
+    if( pA && pY && pY->op==TK_NULL ){
       pA->op = (u8)op;
       sqlite3ExprDelete(db, pA->pRight);
       pA->pRight = 0;
@@ -129384,14 +130018,11 @@ static void yy_reduce(
   **     break;
   */
 /********** Begin reduce actions **********************************************/
-      case 5: /* explain ::= */
-{ sqlite3BeginParse(pParse, 0); }
-        break;
       case 6: /* explain ::= EXPLAIN */
-{ sqlite3BeginParse(pParse, 1); }
+{ pParse->explain = 1; }
         break;
       case 7: /* explain ::= EXPLAIN QUERY PLAN */
-{ sqlite3BeginParse(pParse, 2); }
+{ pParse->explain = 2; }
         break;
       case 8: /* cmdx ::= cmd */
 { sqlite3FinishCoding(pParse); }
@@ -129438,7 +130069,7 @@ static void yy_reduce(
         break;
       case 27: /* createkw ::= CREATE */
 {
-  pParse->db->lookaside.bEnabled = 0;
+  disableLookaside(pParse);
   yygotominor.yy0 = yymsp[0].minor.yy0;
 }
         break;
@@ -130520,7 +131151,7 @@ static void yy_reduce(
         break;
       case 307: /* add_column_fullname ::= fullname */
 {
-  pParse->db->lookaside.bEnabled = 0;
+  disableLookaside(pParse);
   sqlite3AlterBeginAddColumn(pParse, yymsp[0].minor.yy259);
 }
         break;
@@ -130566,6 +131197,7 @@ static void yy_reduce(
       /* (2) cmdlist ::= ecmd */ yytestcase(yyruleno==2);
       /* (3) ecmd ::= SEMI */ yytestcase(yyruleno==3);
       /* (4) ecmd ::= explain cmdx SEMI */ yytestcase(yyruleno==4);
+      /* (5) explain ::= */ yytestcase(yyruleno==5);
       /* (10) trans_opt ::= */ yytestcase(yyruleno==10);
       /* (11) trans_opt ::= TRANSACTION */ yytestcase(yyruleno==11);
       /* (12) trans_opt ::= TRANSACTION nm */ yytestcase(yyruleno==12);
@@ -130899,12 +131531,92 @@ SQLITE_PRIVATE void sqlite3Parser(
 /* #include "sqliteInt.h" */
 /* #include <stdlib.h> */
 
+/* Character classes for tokenizing
+**
+** In the sqlite3GetToken() function, a switch() on aiClass[c] is implemented
+** using a lookup table, whereas a switch() directly on c uses a binary search.
+** The lookup table is much faster.  To maximize speed, and to ensure that
+** a lookup table is used, all of the classes need to be small integers and
+** all of them need to be used within the switch.
+*/
+#define CC_X          0    /* The letter 'x', or start of BLOB literal */
+#define CC_KYWD       1    /* Alphabetics or '_'.  Usable in a keyword */
+#define CC_ID         2    /* unicode characters usable in IDs */
+#define CC_DIGIT      3    /* Digits */
+#define CC_DOLLAR     4    /* '$' */
+#define CC_VARALPHA   5    /* '@', '#', ':'.  Alphabetic SQL variables */
+#define CC_VARNUM     6    /* '?'.  Numeric SQL variables */
+#define CC_SPACE      7    /* Space characters */
+#define CC_QUOTE      8    /* '"', '\'', or '`'.  String literals, quoted ids */
+#define CC_QUOTE2     9    /* '['.   [...] style quoted ids */
+#define CC_PIPE      10    /* '|'.   Bitwise OR or concatenate */
+#define CC_MINUS     11    /* '-'.  Minus or SQL-style comment */
+#define CC_LT        12    /* '<'.  Part of < or <= or <> */
+#define CC_GT        13    /* '>'.  Part of > or >= */
+#define CC_EQ        14    /* '='.  Part of = or == */
+#define CC_BANG      15    /* '!'.  Part of != */
+#define CC_SLASH     16    /* '/'.  / or c-style comment */
+#define CC_LP        17    /* '(' */
+#define CC_RP        18    /* ')' */
+#define CC_SEMI      19    /* ';' */
+#define CC_PLUS      20    /* '+' */
+#define CC_STAR      21    /* '*' */
+#define CC_PERCENT   22    /* '%' */
+#define CC_COMMA     23    /* ',' */
+#define CC_AND       24    /* '&' */
+#define CC_TILDA     25    /* '~' */
+#define CC_DOT       26    /* '.' */
+#define CC_ILLEGAL   27    /* Illegal character */
+
+static const unsigned char aiClass[] = {
+#ifdef SQLITE_ASCII
+/*         x0  x1  x2  x3  x4  x5  x6  x7  x8  x9  xa  xb  xc  xd  xe  xf */
+/* 0x */   27, 27, 27, 27, 27, 27, 27, 27, 27,  7,  7, 27,  7,  7, 27, 27,
+/* 1x */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+/* 2x */    7, 15,  8,  5,  4, 22, 24,  8, 17, 18, 21, 20, 23, 11, 26, 16,
+/* 3x */    3,  3,  3,  3,  3,  3,  3,  3,  3,  3,  5, 19, 12, 14, 13,  6,
+/* 4x */    5,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+/* 5x */    1,  1,  1,  1,  1,  1,  1,  1,  0,  1,  1,  9, 27, 27, 27,  1,
+/* 6x */    8,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
+/* 7x */    1,  1,  1,  1,  1,  1,  1,  1,  0,  1,  1, 27, 10, 27, 25, 27,
+/* 8x */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+/* 9x */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+/* Ax */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+/* Bx */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+/* Cx */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+/* Dx */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+/* Ex */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,
+/* Fx */    2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2,  2
+#endif
+#ifdef SQLITE_EBCDIC
+/*         x0  x1  x2  x3  x4  x5  x6  x7  x8  x9  xa  xb  xc  xd  xe  xf */
+/* 0x */   27, 27, 27, 27, 27,  7, 27, 27, 27, 27, 27, 27,  7,  7, 27, 27,
+/* 1x */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+/* 2x */   27, 27, 27, 27, 27,  7, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+/* 3x */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+/* 4x */    7, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 12, 17, 20, 10,
+/* 5x */   24, 27, 27, 27, 27, 27, 27, 27, 27, 27, 15,  4, 21, 18, 19, 27,
+/* 6x */   11, 16, 27, 27, 27, 27, 27, 27, 27, 27, 27, 23, 22,  1, 13,  7,
+/* 7x */   27, 27, 27, 27, 27, 27, 27, 27, 27,  8,  5,  5,  5,  8, 14,  8,
+/* 8x */   27,  1,  1,  1,  1,  1,  1,  1,  1,  1, 27, 27, 27, 27, 27, 27,
+/* 9x */   27,  1,  1,  1,  1,  1,  1,  1,  1,  1, 27, 27, 27, 27, 27, 27,
+/* 9x */   25,  1,  1,  1,  1,  1,  1,  0,  1,  1, 27, 27, 27, 27, 27, 27,
+/* Bx */   27, 27, 27, 27, 27, 27, 27, 27, 27, 27,  9, 27, 27, 27, 27, 27,
+/* Cx */   27,  1,  1,  1,  1,  1,  1,  1,  1,  1, 27, 27, 27, 27, 27, 27,
+/* Dx */   27,  1,  1,  1,  1,  1,  1,  1,  1,  1, 27, 27, 27, 27, 27, 27,
+/* Ex */   27, 27,  1,  1,  1,  1,  1,  0,  1,  1, 27, 27, 27, 27, 27, 27,
+/* Fx */    3,  3,  3,  3,  3,  3,  3,  3,  3,  3, 27, 27, 27, 27, 27, 27,
+#endif
+};
+
 /*
-** The charMap() macro maps alphabetic characters into their
+** The charMap() macro maps alphabetic characters (only) into their
 ** lower-case ASCII equivalent.  On ASCII machines, this is just
 ** an upper-to-lower case map.  On EBCDIC machines we also need
-** to adjust the encoding.  Only alphabetic characters and underscores
-** need to be translated.
+** to adjust the encoding.  The mapping is only valid for alphabetics
+** which are the only characters for which this feature is used. 
+**
+** Used by keywordhash.h
 */
 #ifdef SQLITE_ASCII
 # define charMap(X) sqlite3UpperToLower[(unsigned char)X]
@@ -130938,7 +131650,7 @@ const unsigned char ebcdicToAscii[] = {
 ** returned.  If the input is not a keyword, TK_ID is returned.
 **
 ** The implementation of this routine was generated by a program,
-** mkkeywordhash.h, located in the tool subdirectory of the distribution.
+** mkkeywordhash.c, located in the tool subdirectory of the distribution.
 ** The output of the mkkeywordhash.c program is written into a file
 ** named keywordhash.h and then included into this source file by
 ** the #include below.
@@ -131079,138 +131791,147 @@ static int keywordCode(const char *z, int n, int *pType){
     TK_JOIN_KW,    TK_ROLLBACK,   TK_ROW,        TK_UNION,      TK_USING,      
     TK_VACUUM,     TK_VIEW,       TK_INITIALLY,  TK_ALL,        
   };
-  int h, i;
+  int i, j;
+  const char *zKW;
   if( n>=2 ){
-    h = ((charMap(z[0])*4) ^ (charMap(z[n-1])*3) ^ n) % 127;
-    for(i=((int)aHash[h])-1; i>=0; i=((int)aNext[i])-1){
-      if( aLen[i]==n && sqlite3StrNICmp(&zText[aOffset[i]],z,n)==0 ){
-        testcase( i==0 ); /* REINDEX */
-        testcase( i==1 ); /* INDEXED */
-        testcase( i==2 ); /* INDEX */
-        testcase( i==3 ); /* DESC */
-        testcase( i==4 ); /* ESCAPE */
-        testcase( i==5 ); /* EACH */
-        testcase( i==6 ); /* CHECK */
-        testcase( i==7 ); /* KEY */
-        testcase( i==8 ); /* BEFORE */
-        testcase( i==9 ); /* FOREIGN */
-        testcase( i==10 ); /* FOR */
-        testcase( i==11 ); /* IGNORE */
-        testcase( i==12 ); /* REGEXP */
-        testcase( i==13 ); /* EXPLAIN */
-        testcase( i==14 ); /* INSTEAD */
-        testcase( i==15 ); /* ADD */
-        testcase( i==16 ); /* DATABASE */
-        testcase( i==17 ); /* AS */
-        testcase( i==18 ); /* SELECT */
-        testcase( i==19 ); /* TABLE */
-        testcase( i==20 ); /* LEFT */
-        testcase( i==21 ); /* THEN */
-        testcase( i==22 ); /* END */
-        testcase( i==23 ); /* DEFERRABLE */
-        testcase( i==24 ); /* ELSE */
-        testcase( i==25 ); /* EXCEPT */
-        testcase( i==26 ); /* TRANSACTION */
-        testcase( i==27 ); /* ACTION */
-        testcase( i==28 ); /* ON */
-        testcase( i==29 ); /* NATURAL */
-        testcase( i==30 ); /* ALTER */
-        testcase( i==31 ); /* RAISE */
-        testcase( i==32 ); /* EXCLUSIVE */
-        testcase( i==33 ); /* EXISTS */
-        testcase( i==34 ); /* SAVEPOINT */
-        testcase( i==35 ); /* INTERSECT */
-        testcase( i==36 ); /* TRIGGER */
-        testcase( i==37 ); /* REFERENCES */
-        testcase( i==38 ); /* CONSTRAINT */
-        testcase( i==39 ); /* INTO */
-        testcase( i==40 ); /* OFFSET */
-        testcase( i==41 ); /* OF */
-        testcase( i==42 ); /* SET */
-        testcase( i==43 ); /* TEMPORARY */
-        testcase( i==44 ); /* TEMP */
-        testcase( i==45 ); /* OR */
-        testcase( i==46 ); /* UNIQUE */
-        testcase( i==47 ); /* QUERY */
-        testcase( i==48 ); /* WITHOUT */
-        testcase( i==49 ); /* WITH */
-        testcase( i==50 ); /* OUTER */
-        testcase( i==51 ); /* RELEASE */
-        testcase( i==52 ); /* ATTACH */
-        testcase( i==53 ); /* HAVING */
-        testcase( i==54 ); /* GROUP */
-        testcase( i==55 ); /* UPDATE */
-        testcase( i==56 ); /* BEGIN */
-        testcase( i==57 ); /* INNER */
-        testcase( i==58 ); /* RECURSIVE */
-        testcase( i==59 ); /* BETWEEN */
-        testcase( i==60 ); /* NOTNULL */
-        testcase( i==61 ); /* NOT */
-        testcase( i==62 ); /* NO */
-        testcase( i==63 ); /* NULL */
-        testcase( i==64 ); /* LIKE */
-        testcase( i==65 ); /* CASCADE */
-        testcase( i==66 ); /* ASC */
-        testcase( i==67 ); /* DELETE */
-        testcase( i==68 ); /* CASE */
-        testcase( i==69 ); /* COLLATE */
-        testcase( i==70 ); /* CREATE */
-        testcase( i==71 ); /* CURRENT_DATE */
-        testcase( i==72 ); /* DETACH */
-        testcase( i==73 ); /* IMMEDIATE */
-        testcase( i==74 ); /* JOIN */
-        testcase( i==75 ); /* INSERT */
-        testcase( i==76 ); /* MATCH */
-        testcase( i==77 ); /* PLAN */
-        testcase( i==78 ); /* ANALYZE */
-        testcase( i==79 ); /* PRAGMA */
-        testcase( i==80 ); /* ABORT */
-        testcase( i==81 ); /* VALUES */
-        testcase( i==82 ); /* VIRTUAL */
-        testcase( i==83 ); /* LIMIT */
-        testcase( i==84 ); /* WHEN */
-        testcase( i==85 ); /* WHERE */
-        testcase( i==86 ); /* RENAME */
-        testcase( i==87 ); /* AFTER */
-        testcase( i==88 ); /* REPLACE */
-        testcase( i==89 ); /* AND */
-        testcase( i==90 ); /* DEFAULT */
-        testcase( i==91 ); /* AUTOINCREMENT */
-        testcase( i==92 ); /* TO */
-        testcase( i==93 ); /* IN */
-        testcase( i==94 ); /* CAST */
-        testcase( i==95 ); /* COLUMN */
-        testcase( i==96 ); /* COMMIT */
-        testcase( i==97 ); /* CONFLICT */
-        testcase( i==98 ); /* CROSS */
-        testcase( i==99 ); /* CURRENT_TIMESTAMP */
-        testcase( i==100 ); /* CURRENT_TIME */
-        testcase( i==101 ); /* PRIMARY */
-        testcase( i==102 ); /* DEFERRED */
-        testcase( i==103 ); /* DISTINCT */
-        testcase( i==104 ); /* IS */
-        testcase( i==105 ); /* DROP */
-        testcase( i==106 ); /* FAIL */
-        testcase( i==107 ); /* FROM */
-        testcase( i==108 ); /* FULL */
-        testcase( i==109 ); /* GLOB */
-        testcase( i==110 ); /* BY */
-        testcase( i==111 ); /* IF */
-        testcase( i==112 ); /* ISNULL */
-        testcase( i==113 ); /* ORDER */
-        testcase( i==114 ); /* RESTRICT */
-        testcase( i==115 ); /* RIGHT */
-        testcase( i==116 ); /* ROLLBACK */
-        testcase( i==117 ); /* ROW */
-        testcase( i==118 ); /* UNION */
-        testcase( i==119 ); /* USING */
-        testcase( i==120 ); /* VACUUM */
-        testcase( i==121 ); /* VIEW */
-        testcase( i==122 ); /* INITIALLY */
-        testcase( i==123 ); /* ALL */
-        *pType = aCode[i];
-        break;
-      }
+    i = ((charMap(z[0])*4) ^ (charMap(z[n-1])*3) ^ n) % 127;
+    for(i=((int)aHash[i])-1; i>=0; i=((int)aNext[i])-1){
+      if( aLen[i]!=n ) continue;
+      j = 0;
+      zKW = &zText[aOffset[i]];
+#ifdef SQLITE_ASCII
+      while( j<n && (z[j]&~0x20)==zKW[j] ){ j++; }
+#endif
+#ifdef SQLITE_EBCDIC
+      while( j<n && toupper(z[j])==zKW[j] ){ j++; }
+#endif
+      if( j<n ) continue;
+      testcase( i==0 ); /* REINDEX */
+      testcase( i==1 ); /* INDEXED */
+      testcase( i==2 ); /* INDEX */
+      testcase( i==3 ); /* DESC */
+      testcase( i==4 ); /* ESCAPE */
+      testcase( i==5 ); /* EACH */
+      testcase( i==6 ); /* CHECK */
+      testcase( i==7 ); /* KEY */
+      testcase( i==8 ); /* BEFORE */
+      testcase( i==9 ); /* FOREIGN */
+      testcase( i==10 ); /* FOR */
+      testcase( i==11 ); /* IGNORE */
+      testcase( i==12 ); /* REGEXP */
+      testcase( i==13 ); /* EXPLAIN */
+      testcase( i==14 ); /* INSTEAD */
+      testcase( i==15 ); /* ADD */
+      testcase( i==16 ); /* DATABASE */
+      testcase( i==17 ); /* AS */
+      testcase( i==18 ); /* SELECT */
+      testcase( i==19 ); /* TABLE */
+      testcase( i==20 ); /* LEFT */
+      testcase( i==21 ); /* THEN */
+      testcase( i==22 ); /* END */
+      testcase( i==23 ); /* DEFERRABLE */
+      testcase( i==24 ); /* ELSE */
+      testcase( i==25 ); /* EXCEPT */
+      testcase( i==26 ); /* TRANSACTION */
+      testcase( i==27 ); /* ACTION */
+      testcase( i==28 ); /* ON */
+      testcase( i==29 ); /* NATURAL */
+      testcase( i==30 ); /* ALTER */
+      testcase( i==31 ); /* RAISE */
+      testcase( i==32 ); /* EXCLUSIVE */
+      testcase( i==33 ); /* EXISTS */
+      testcase( i==34 ); /* SAVEPOINT */
+      testcase( i==35 ); /* INTERSECT */
+      testcase( i==36 ); /* TRIGGER */
+      testcase( i==37 ); /* REFERENCES */
+      testcase( i==38 ); /* CONSTRAINT */
+      testcase( i==39 ); /* INTO */
+      testcase( i==40 ); /* OFFSET */
+      testcase( i==41 ); /* OF */
+      testcase( i==42 ); /* SET */
+      testcase( i==43 ); /* TEMPORARY */
+      testcase( i==44 ); /* TEMP */
+      testcase( i==45 ); /* OR */
+      testcase( i==46 ); /* UNIQUE */
+      testcase( i==47 ); /* QUERY */
+      testcase( i==48 ); /* WITHOUT */
+      testcase( i==49 ); /* WITH */
+      testcase( i==50 ); /* OUTER */
+      testcase( i==51 ); /* RELEASE */
+      testcase( i==52 ); /* ATTACH */
+      testcase( i==53 ); /* HAVING */
+      testcase( i==54 ); /* GROUP */
+      testcase( i==55 ); /* UPDATE */
+      testcase( i==56 ); /* BEGIN */
+      testcase( i==57 ); /* INNER */
+      testcase( i==58 ); /* RECURSIVE */
+      testcase( i==59 ); /* BETWEEN */
+      testcase( i==60 ); /* NOTNULL */
+      testcase( i==61 ); /* NOT */
+      testcase( i==62 ); /* NO */
+      testcase( i==63 ); /* NULL */
+      testcase( i==64 ); /* LIKE */
+      testcase( i==65 ); /* CASCADE */
+      testcase( i==66 ); /* ASC */
+      testcase( i==67 ); /* DELETE */
+      testcase( i==68 ); /* CASE */
+      testcase( i==69 ); /* COLLATE */
+      testcase( i==70 ); /* CREATE */
+      testcase( i==71 ); /* CURRENT_DATE */
+      testcase( i==72 ); /* DETACH */
+      testcase( i==73 ); /* IMMEDIATE */
+      testcase( i==74 ); /* JOIN */
+      testcase( i==75 ); /* INSERT */
+      testcase( i==76 ); /* MATCH */
+      testcase( i==77 ); /* PLAN */
+      testcase( i==78 ); /* ANALYZE */
+      testcase( i==79 ); /* PRAGMA */
+      testcase( i==80 ); /* ABORT */
+      testcase( i==81 ); /* VALUES */
+      testcase( i==82 ); /* VIRTUAL */
+      testcase( i==83 ); /* LIMIT */
+      testcase( i==84 ); /* WHEN */
+      testcase( i==85 ); /* WHERE */
+      testcase( i==86 ); /* RENAME */
+      testcase( i==87 ); /* AFTER */
+      testcase( i==88 ); /* REPLACE */
+      testcase( i==89 ); /* AND */
+      testcase( i==90 ); /* DEFAULT */
+      testcase( i==91 ); /* AUTOINCREMENT */
+      testcase( i==92 ); /* TO */
+      testcase( i==93 ); /* IN */
+      testcase( i==94 ); /* CAST */
+      testcase( i==95 ); /* COLUMN */
+      testcase( i==96 ); /* COMMIT */
+      testcase( i==97 ); /* CONFLICT */
+      testcase( i==98 ); /* CROSS */
+      testcase( i==99 ); /* CURRENT_TIMESTAMP */
+      testcase( i==100 ); /* CURRENT_TIME */
+      testcase( i==101 ); /* PRIMARY */
+      testcase( i==102 ); /* DEFERRED */
+      testcase( i==103 ); /* DISTINCT */
+      testcase( i==104 ); /* IS */
+      testcase( i==105 ); /* DROP */
+      testcase( i==106 ); /* FAIL */
+      testcase( i==107 ); /* FROM */
+      testcase( i==108 ); /* FULL */
+      testcase( i==109 ); /* GLOB */
+      testcase( i==110 ); /* BY */
+      testcase( i==111 ); /* IF */
+      testcase( i==112 ); /* ISNULL */
+      testcase( i==113 ); /* ORDER */
+      testcase( i==114 ); /* RESTRICT */
+      testcase( i==115 ); /* RIGHT */
+      testcase( i==116 ); /* ROLLBACK */
+      testcase( i==117 ); /* ROW */
+      testcase( i==118 ); /* UNION */
+      testcase( i==119 ); /* USING */
+      testcase( i==120 ); /* VACUUM */
+      testcase( i==121 ); /* VIEW */
+      testcase( i==122 ); /* INITIALLY */
+      testcase( i==123 ); /* ALL */
+      *pType = aCode[i];
+      break;
     }
   }
   return n;
@@ -131271,13 +131992,15 @@ SQLITE_PRIVATE int sqlite3IsIdChar(u8 c){ return IdChar(c); }
 
 
 /*
-** Return the length of the token that begins at z[0]. 
+** Return the length (in bytes) of the token that begins at z[0]. 
 ** Store the token type in *tokenType before returning.
 */
 SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
   int i, c;
-  switch( *z ){
-    case ' ': case '\t': case '\n': case '\f': case '\r': {
+  switch( aiClass[*z] ){  /* Switch on the character-class of the first byte
+                          ** of the token. See the comment on the CC_ defines
+                          ** above. */
+    case CC_SPACE: {
       testcase( z[0]==' ' );
       testcase( z[0]=='\t' );
       testcase( z[0]=='\n' );
@@ -131287,7 +132010,7 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
       *tokenType = TK_SPACE;
       return i;
     }
-    case '-': {
+    case CC_MINUS: {
       if( z[1]=='-' ){
         for(i=2; (c=z[i])!=0 && c!='\n'; i++){}
         *tokenType = TK_SPACE;   /* IMP: R-22934-25134 */
@@ -131296,27 +132019,27 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
       *tokenType = TK_MINUS;
       return 1;
     }
-    case '(': {
+    case CC_LP: {
       *tokenType = TK_LP;
       return 1;
     }
-    case ')': {
+    case CC_RP: {
       *tokenType = TK_RP;
       return 1;
     }
-    case ';': {
+    case CC_SEMI: {
       *tokenType = TK_SEMI;
       return 1;
     }
-    case '+': {
+    case CC_PLUS: {
       *tokenType = TK_PLUS;
       return 1;
     }
-    case '*': {
+    case CC_STAR: {
       *tokenType = TK_STAR;
       return 1;
     }
-    case '/': {
+    case CC_SLASH: {
       if( z[1]!='*' || z[2]==0 ){
         *tokenType = TK_SLASH;
         return 1;
@@ -131326,15 +132049,15 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
       *tokenType = TK_SPACE;   /* IMP: R-22934-25134 */
       return i;
     }
-    case '%': {
+    case CC_PERCENT: {
       *tokenType = TK_REM;
       return 1;
     }
-    case '=': {
+    case CC_EQ: {
       *tokenType = TK_EQ;
       return 1 + (z[1]=='=');
     }
-    case '<': {
+    case CC_LT: {
       if( (c=z[1])=='=' ){
         *tokenType = TK_LE;
         return 2;
@@ -131349,7 +132072,7 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
         return 1;
       }
     }
-    case '>': {
+    case CC_GT: {
       if( (c=z[1])=='=' ){
         *tokenType = TK_GE;
         return 2;
@@ -131361,7 +132084,7 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
         return 1;
       }
     }
-    case '!': {
+    case CC_BANG: {
       if( z[1]!='=' ){
         *tokenType = TK_ILLEGAL;
         return 2;
@@ -131370,7 +132093,7 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
         return 2;
       }
     }
-    case '|': {
+    case CC_PIPE: {
       if( z[1]!='|' ){
         *tokenType = TK_BITOR;
         return 1;
@@ -131379,21 +132102,19 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
         return 2;
       }
     }
-    case ',': {
+    case CC_COMMA: {
       *tokenType = TK_COMMA;
       return 1;
     }
-    case '&': {
+    case CC_AND: {
       *tokenType = TK_BITAND;
       return 1;
     }
-    case '~': {
+    case CC_TILDA: {
       *tokenType = TK_BITNOT;
       return 1;
     }
-    case '`':
-    case '\'':
-    case '"': {
+    case CC_QUOTE: {
       int delim = z[0];
       testcase( delim=='`' );
       testcase( delim=='\'' );
@@ -131418,7 +132139,7 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
         return i;
       }
     }
-    case '.': {
+    case CC_DOT: {
 #ifndef SQLITE_OMIT_FLOATING_POINT
       if( !sqlite3Isdigit(z[1]) )
 #endif
@@ -131429,8 +132150,7 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
       /* If the next character is a digit, this is a floating point
       ** number that begins with ".".  Fall thru into the next case */
     }
-    case '0': case '1': case '2': case '3': case '4':
-    case '5': case '6': case '7': case '8': case '9': {
+    case CC_DIGIT: {
       testcase( z[0]=='0' );  testcase( z[0]=='1' );  testcase( z[0]=='2' );
       testcase( z[0]=='3' );  testcase( z[0]=='4' );  testcase( z[0]=='5' );
       testcase( z[0]=='6' );  testcase( z[0]=='7' );  testcase( z[0]=='8' );
@@ -131465,22 +132185,18 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
       }
       return i;
     }
-    case '[': {
+    case CC_QUOTE2: {
       for(i=1, c=z[0]; c!=']' && (c=z[i])!=0; i++){}
       *tokenType = c==']' ? TK_ID : TK_ILLEGAL;
       return i;
     }
-    case '?': {
+    case CC_VARNUM: {
       *tokenType = TK_VARIABLE;
       for(i=1; sqlite3Isdigit(z[i]); i++){}
       return i;
     }
-#ifndef SQLITE_OMIT_TCL_VARIABLE
-    case '$':
-#endif
-    case '@':  /* For compatibility with MS SQL Server */
-    case '#':
-    case ':': {
+    case CC_DOLLAR:
+    case CC_VARALPHA: {
       int n = 0;
       testcase( z[0]=='$' );  testcase( z[0]=='@' );
       testcase( z[0]==':' );  testcase( z[0]=='#' );
@@ -131509,8 +132225,20 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
       if( n==0 ) *tokenType = TK_ILLEGAL;
       return i;
     }
+    case CC_KYWD: {
+      for(i=1; aiClass[z[i]]<=CC_KYWD; i++){}
+      if( IdChar(z[i]) ){
+        /* This token started out using characters that can appear in keywords,
+        ** but z[i] is a character not allowed within keywords, so this must
+        ** be an identifier instead */
+        i++;
+        break;
+      }
+      *tokenType = TK_ID;
+      return keywordCode((char*)z, i, tokenType);
+    }
 #ifndef SQLITE_OMIT_BLOB_LITERAL
-    case 'x': case 'X': {
+    case CC_X: {
       testcase( z[0]=='x' ); testcase( z[0]=='X' );
       if( z[1]=='\'' ){
         *tokenType = TK_BLOB;
@@ -131522,20 +132250,22 @@ SQLITE_PRIVATE int sqlite3GetToken(const unsigned char *z, int *tokenType){
         if( z[i] ) i++;
         return i;
       }
-      /* Otherwise fall through to the next case */
+      /* If it is not a BLOB literal, then it must be an ID, since no
+      ** SQL keywords start with the letter 'x'.  Fall through */
     }
 #endif
+    case CC_ID: {
+      i = 1;
+      break;
+    }
     default: {
-      if( !IdChar(*z) ){
-        break;
-      }
-      for(i=1; IdChar(z[i]); i++){}
-      *tokenType = TK_ID;
-      return keywordCode((char*)z, i, tokenType);
+      *tokenType = TK_ILLEGAL;
+      return 1;
     }
   }
-  *tokenType = TK_ILLEGAL;
-  return 1;
+  while( IdChar(z[i]) ){ i++; }
+  *tokenType = TK_ID;
+  return i;
 }
 
 /*
@@ -131551,7 +132281,6 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr
   void *pEngine;                  /* The LEMON-generated LALR(1) parser */
   int tokenType;                  /* type of the next token */
   int lastTokenParsed = -1;       /* type of the previous token */
-  u8 enableLookaside;             /* Saved value of db->lookaside.bEnabled */
   sqlite3 *db = pParse->db;       /* The database connection */
   int mxSqlLen;                   /* Max length of an SQL string */
 
@@ -131567,7 +132296,7 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr
   /* sqlite3ParserTrace(stdout, "parser: "); */
   pEngine = sqlite3ParserAlloc(sqlite3Malloc);
   if( pEngine==0 ){
-    db->mallocFailed = 1;
+    sqlite3OomFault(db);
     return SQLITE_NOMEM;
   }
   assert( pParse->pNewTable==0 );
@@ -131575,8 +132304,6 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr
   assert( pParse->nVar==0 );
   assert( pParse->nzVar==0 );
   assert( pParse->azVar==0 );
-  enableLookaside = db->lookaside.bEnabled;
-  if( db->lookaside.pStart ) db->lookaside.bEnabled = 1;
   while( zSql[i]!=0 ){
     assert( i>=0 );
     pParse->sLastToken.z = &zSql[i];
@@ -131589,7 +132316,6 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr
     if( tokenType>=TK_SPACE ){
       assert( tokenType==TK_SPACE || tokenType==TK_ILLEGAL );
       if( db->u1.isInterrupted ){
-        sqlite3ErrorMsg(pParse, "interrupt");
         pParse->rc = SQLITE_INTERRUPT;
         break;
       }
@@ -131624,7 +132350,6 @@ SQLITE_PRIVATE int sqlite3RunParser(Parse *pParse, const char *zSql, char **pzEr
   sqlite3_mutex_leave(sqlite3MallocMutex());
 #endif /* YYDEBUG */
   sqlite3ParserFree(pEngine, sqlite3_free);
-  db->lookaside.bEnabled = enableLookaside;
   if( db->mallocFailed ){
     pParse->rc = SQLITE_NOMEM;
   }
@@ -132765,12 +133490,12 @@ static int setupLookaside(sqlite3 *db, void *pBuf, int sz, int cnt){
       p = (LookasideSlot*)&((u8*)p)[sz];
     }
     db->lookaside.pEnd = p;
-    db->lookaside.bEnabled = 1;
+    db->lookaside.bDisable = 0;
     db->lookaside.bMalloced = pBuf==0 ?1:0;
   }else{
     db->lookaside.pStart = db;
     db->lookaside.pEnd = db;
-    db->lookaside.bEnabled = 0;
+    db->lookaside.bDisable = 1;
     db->lookaside.bMalloced = 0;
   }
 #endif /* SQLITE_OMIT_LOOKASIDE */
@@ -133642,7 +134367,7 @@ SQLITE_PRIVATE int sqlite3CreateFunc(
   int nArg,
   int enc,
   void *pUserData,
-  void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
+  void (*xSFunc)(sqlite3_context*,int,sqlite3_value **),
   void (*xStep)(sqlite3_context*,int,sqlite3_value **),
   void (*xFinal)(sqlite3_context*),
   FuncDestructor *pDestructor
@@ -133653,9 +134378,9 @@ SQLITE_PRIVATE int sqlite3CreateFunc(
 
   assert( sqlite3_mutex_held(db->mutex) );
   if( zFunctionName==0 ||
-      (xFunc && (xFinal || xStep)) || 
-      (!xFunc && (xFinal && !xStep)) ||
-      (!xFunc && (!xFinal && xStep)) ||
+      (xSFunc && (xFinal || xStep)) || 
+      (!xSFunc && (xFinal && !xStep)) ||
+      (!xSFunc && (!xFinal && xStep)) ||
       (nArg<-1 || nArg>SQLITE_MAX_FUNCTION_ARG) ||
       (255<(nName = sqlite3Strlen30( zFunctionName))) ){
     return SQLITE_MISUSE_BKPT;
@@ -133678,10 +134403,10 @@ SQLITE_PRIVATE int sqlite3CreateFunc(
   }else if( enc==SQLITE_ANY ){
     int rc;
     rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF8|extraFlags,
-         pUserData, xFunc, xStep, xFinal, pDestructor);
+         pUserData, xSFunc, xStep, xFinal, pDestructor);
     if( rc==SQLITE_OK ){
       rc = sqlite3CreateFunc(db, zFunctionName, nArg, SQLITE_UTF16LE|extraFlags,
-          pUserData, xFunc, xStep, xFinal, pDestructor);
+          pUserData, xSFunc, xStep, xFinal, pDestructor);
     }
     if( rc!=SQLITE_OK ){
       return rc;
@@ -133725,8 +134450,7 @@ SQLITE_PRIVATE int sqlite3CreateFunc(
   p->pDestructor = pDestructor;
   p->funcFlags = (p->funcFlags & SQLITE_FUNC_ENCMASK) | extraFlags;
   testcase( p->funcFlags & SQLITE_DETERMINISTIC );
-  p->xFunc = xFunc;
-  p->xStep = xStep;
+  p->xSFunc = xSFunc ? xSFunc : xStep;
   p->xFinalize = xFinal;
   p->pUserData = pUserData;
   p->nArg = (u16)nArg;
@@ -133742,11 +134466,11 @@ SQLITE_API int SQLITE_STDCALL sqlite3_create_function(
   int nArg,
   int enc,
   void *p,
-  void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
+  void (*xSFunc)(sqlite3_context*,int,sqlite3_value **),
   void (*xStep)(sqlite3_context*,int,sqlite3_value **),
   void (*xFinal)(sqlite3_context*)
 ){
-  return sqlite3_create_function_v2(db, zFunc, nArg, enc, p, xFunc, xStep,
+  return sqlite3_create_function_v2(db, zFunc, nArg, enc, p, xSFunc, xStep,
                                     xFinal, 0);
 }
 
@@ -133756,7 +134480,7 @@ SQLITE_API int SQLITE_STDCALL sqlite3_create_function_v2(
   int nArg,
   int enc,
   void *p,
-  void (*xFunc)(sqlite3_context*,int,sqlite3_value **),
+  void (*xSFunc)(sqlite3_context*,int,sqlite3_value **),
   void (*xStep)(sqlite3_context*,int,sqlite3_value **),
   void (*xFinal)(sqlite3_context*),
   void (*xDestroy)(void *)
@@ -133779,7 +134503,7 @@ SQLITE_API int SQLITE_STDCALL sqlite3_create_function_v2(
     pArg->xDestroy = xDestroy;
     pArg->pUserData = p;
   }
-  rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p, xFunc, xStep, xFinal, pArg);
+  rc = sqlite3CreateFunc(db, zFunc, nArg, enc, p, xSFunc, xStep, xFinal, pArg);
   if( pArg && pArg->nRef==0 ){
     assert( rc!=SQLITE_OK );
     xDestroy(p);
@@ -133799,7 +134523,7 @@ SQLITE_API int SQLITE_STDCALL sqlite3_create_function16(
   int nArg,
   int eTextRep,
   void *p,
-  void (*xFunc)(sqlite3_context*,int,sqlite3_value**),
+  void (*xSFunc)(sqlite3_context*,int,sqlite3_value**),
   void (*xStep)(sqlite3_context*,int,sqlite3_value**),
   void (*xFinal)(sqlite3_context*)
 ){
@@ -133812,7 +134536,7 @@ SQLITE_API int SQLITE_STDCALL sqlite3_create_function16(
   sqlite3_mutex_enter(db->mutex);
   assert( !db->mallocFailed );
   zFunc8 = sqlite3Utf16to8(db, zFunctionName, -1, SQLITE_UTF16NATIVE);
-  rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xFunc, xStep, xFinal,0);
+  rc = sqlite3CreateFunc(db, zFunc8, nArg, eTextRep, p, xSFunc,xStep,xFinal,0);
   sqlite3DbFree(db, zFunc8);
   rc = sqlite3ApiExit(db, rc);
   sqlite3_mutex_leave(db->mutex);
@@ -134276,7 +135000,7 @@ SQLITE_API const void *SQLITE_STDCALL sqlite3_errmsg16(sqlite3 *db){
     ** be cleared before returning. Do this directly, instead of via
     ** sqlite3ApiExit(), to avoid setting the database handle error message.
     */
-    db->mallocFailed = 0;
+    sqlite3OomClear(db);
   }
   sqlite3_mutex_leave(db->mutex);
   return z;
@@ -134914,7 +135638,7 @@ static int openDatabase(
   db->openFlags = flags;
   rc = sqlite3ParseUri(zVfs, zFilename, &flags, &db->pVfs, &zOpen, &zErrMsg);
   if( rc!=SQLITE_OK ){
-    if( rc==SQLITE_NOMEM ) db->mallocFailed = 1;
+    if( rc==SQLITE_NOMEM ) sqlite3OomFault(db);
     sqlite3ErrorWithMsg(db, rc, zErrMsg ? "%s" : 0, zErrMsg);
     sqlite3_free(zErrMsg);
     goto opendb_out;
@@ -135634,7 +136358,7 @@ SQLITE_API int SQLITE_CDECL sqlite3_test_control(int op, ...){
     */
     case SQLITE_TESTCTRL_ASSERT: {
       volatile int x = 0;
-      assert( (x = va_arg(ap,int))!=0 );
+      assert( /*side-effects-ok*/ (x = va_arg(ap,int))!=0 );
       rc = x;
       break;
     }
@@ -136668,6 +137392,12 @@ SQLITE_PRIVATE void sqlite3ConnectionClosed(sqlite3 *db){
 # define NDEBUG 1
 #endif
 
+/* FTS3/FTS4 require virtual tables */
+#ifdef SQLITE_OMIT_VIRTUALTABLE
+# undef SQLITE_ENABLE_FTS3
+# undef SQLITE_ENABLE_FTS4
+#endif
+
 /*
 ** FTS4 is really an extension for FTS3.  It is enabled using the
 ** SQLITE_ENABLE_FTS3 macro.  But to avoid confusion we also all
@@ -146164,6 +146894,7 @@ static void scalarFunc(
   nName = sqlite3_value_bytes(argv[0])+1;
 
   if( argc==2 ){
+#ifdef SQLITE_ENABLE_FTS3_TOKENIZER
     void *pOld;
     int n = sqlite3_value_bytes(argv[1]);
     if( zName==0 || n!=sizeof(pPtr) ){
@@ -146176,7 +146907,14 @@ static void scalarFunc(
       sqlite3_result_error(context, "out of memory", -1);
       return;
     }
-  }else{
+#else
+    sqlite3_result_error(context, "fts3tokenize: " 
+        "disabled - rebuild with -DSQLITE_ENABLE_FTS3_TOKENIZER", -1
+    );
+    return;
+#endif /* SQLITE_ENABLE_FTS3_TOKENIZER */
+  }else
+  {
     if( zName ){
       pPtr = sqlite3Fts3HashFind(pHash, zName, nName);
     }
@@ -146425,6 +147163,7 @@ finish:
   Tcl_DecrRefCount(pRet);
 }
 
+#ifdef SQLITE_ENABLE_FTS3_TOKENIZER
 static
 int registerTokenizer(
   sqlite3 *db, 
@@ -146446,6 +147185,8 @@ int registerTokenizer(
 
   return sqlite3_finalize(pStmt);
 }
+#endif /* SQLITE_ENABLE_FTS3_TOKENIZER */
+
 
 static
 int queryTokenizer(
@@ -146517,11 +147258,13 @@ static void intTestFunc(
   assert( 0==strcmp(sqlite3_errmsg(db), "unknown tokenizer: nosuchtokenizer") );
 
   /* Test the storage function */
+#ifdef SQLITE_ENABLE_FTS3_TOKENIZER
   rc = registerTokenizer(db, "nosuchtokenizer", p1);
   assert( rc==SQLITE_OK );
   rc = queryTokenizer(db, "nosuchtokenizer", &p2);
   assert( rc==SQLITE_OK );
   assert( p2==p1 );
+#endif
 
   sqlite3_result_text(context, "ok", -1, SQLITE_STATIC);
 }
@@ -161127,7 +161870,7 @@ static void *rbuMalloc(sqlite3rbu *p, int nByte){
   void *pRet = 0;
   if( p->rc==SQLITE_OK ){
     assert( nByte>0 );
-    pRet = sqlite3_malloc(nByte);
+    pRet = sqlite3_malloc64(nByte);
     if( pRet==0 ){
       p->rc = SQLITE_NOMEM;
     }else{
@@ -161173,8 +161916,8 @@ static char *rbuStrndup(const char *zStr, int *pRc){
 
   assert( *pRc==SQLITE_OK );
   if( zStr ){
-    int nCopy = strlen(zStr) + 1;
-    zRet = (char*)sqlite3_malloc(nCopy);
+    size_t nCopy = strlen(zStr) + 1;
+    zRet = (char*)sqlite3_malloc64(nCopy);
     if( zRet ){
       memcpy(zRet, zStr, nCopy);
     }else{
@@ -162522,7 +163265,7 @@ static int rbuCaptureWalRead(sqlite3rbu *pRbu, i64 iOff, int iAmt){
   if( pRbu->nFrame==pRbu->nFrameAlloc ){
     int nNew = (pRbu->nFrameAlloc ? pRbu->nFrameAlloc : 64) * 2;
     RbuFrame *aNew;
-    aNew = (RbuFrame*)sqlite3_realloc(pRbu->aFrame, nNew * sizeof(RbuFrame));
+    aNew = (RbuFrame*)sqlite3_realloc64(pRbu->aFrame, nNew * sizeof(RbuFrame));
     if( aNew==0 ) return SQLITE_NOMEM;
     pRbu->aFrame = aNew;
     pRbu->nFrameAlloc = nNew;
@@ -162587,7 +163330,7 @@ static LPWSTR rbuWinUtf8ToUnicode(const char *zFilename){
   if( nChar==0 ){
     return 0;
   }
-  zWideFilename = sqlite3_malloc( nChar*sizeof(zWideFilename[0]) );
+  zWideFilename = sqlite3_malloc64( nChar*sizeof(zWideFilename[0]) );
   if( zWideFilename==0 ){
     return 0;
   }
@@ -163221,11 +163964,12 @@ SQLITE_API sqlite3rbu *SQLITE_STDCALL sqlite3rbu_open(
   const char *zState
 ){
   sqlite3rbu *p;
-  int nTarget = strlen(zTarget);
-  int nRbu = strlen(zRbu);
-  int nState = zState ? strlen(zState) : 0;
+  size_t nTarget = strlen(zTarget);
+  size_t nRbu = strlen(zRbu);
+  size_t nState = zState ? strlen(zState) : 0;
+  size_t nByte = sizeof(sqlite3rbu) + nTarget+1 + nRbu+1+ nState+1;
 
-  p = (sqlite3rbu*)sqlite3_malloc(sizeof(sqlite3rbu)+nTarget+1+nRbu+1+nState+1);
+  p = (sqlite3rbu*)sqlite3_malloc64(nByte);
   if( p ){
     RbuState *pState = 0;
 
@@ -163362,7 +164106,7 @@ SQLITE_API sqlite3 *SQLITE_STDCALL sqlite3rbu_db(sqlite3rbu *pRbu, int bRbu){
 static void rbuEditErrmsg(sqlite3rbu *p){
   if( p->rc==SQLITE_CONSTRAINT && p->zErrmsg ){
     int i;
-    int nErrmsg = strlen(p->zErrmsg);
+    size_t nErrmsg = strlen(p->zErrmsg);
     for(i=0; i<(nErrmsg-8); i++){
       if( memcmp(&p->zErrmsg[i], "rbu_imp_", 8)==0 ){
         int nDel = 8;
@@ -163826,7 +164570,7 @@ static int rbuVfsShmMap(
   if( eStage==RBU_STAGE_OAL || eStage==RBU_STAGE_MOVE ){
     if( iRegion<=p->nShm ){
       int nByte = (iRegion+1) * sizeof(char*);
-      char **apNew = (char**)sqlite3_realloc(p->apShm, nByte);
+      char **apNew = (char**)sqlite3_realloc64(p->apShm, nByte);
       if( apNew==0 ){
         rc = SQLITE_NOMEM;
       }else{
@@ -163837,7 +164581,7 @@ static int rbuVfsShmMap(
     }
 
     if( rc==SQLITE_OK && p->apShm[iRegion]==0 ){
-      char *pNew = (char*)sqlite3_malloc(szRegion);
+      char *pNew = (char*)sqlite3_malloc64(szRegion);
       if( pNew==0 ){
         rc = SQLITE_NOMEM;
       }else{
@@ -163947,7 +164691,7 @@ static int rbuVfsOpen(
       ** the name of the *-wal file this db connection will use. SQLite
       ** happens to pass a pointer to this buffer when using xAccess()
       ** or xOpen() to operate on the *-wal file.  */
-      int n = strlen(zName);
+      int n = (int)strlen(zName);
       const char *z = &zName[n];
       if( flags & SQLITE_OPEN_URI ){
         int odd = 0;
@@ -163973,8 +164717,8 @@ static int rbuVfsOpen(
           ** code ensures that the string passed to xOpen() is terminated by a
           ** pair of '\0' bytes in case the VFS attempts to extract a URI 
           ** parameter from it.  */
-          int nCopy = strlen(zName);
-          char *zCopy = sqlite3_malloc(nCopy+2);
+          size_t nCopy = strlen(zName);
+          char *zCopy = sqlite3_malloc64(nCopy+2);
           if( zCopy ){
             memcpy(zCopy, zName, nCopy);
             zCopy[nCopy-3] = 'o';
@@ -164203,13 +164947,13 @@ SQLITE_API int SQLITE_STDCALL sqlite3rbu_create_vfs(const char *zName, const cha
   };
 
   rbu_vfs *pNew = 0;              /* Newly allocated VFS */
-  int nName;
   int rc = SQLITE_OK;
+  size_t nName;
+  size_t nByte;
 
-  int nByte;
   nName = strlen(zName);
   nByte = sizeof(rbu_vfs) + nName + 1;
-  pNew = (rbu_vfs*)sqlite3_malloc(nByte);
+  pNew = (rbu_vfs*)sqlite3_malloc64(nByte);
   if( pNew==0 ){
     rc = SQLITE_NOMEM;
   }else{
@@ -164403,7 +165147,9 @@ static int statConnect(
   int iDb;
 
   if( argc>=4 ){
-    iDb = sqlite3FindDbName(db, argv[3]);
+    Token nm;
+    sqlite3TokenInit(&nm, (char*)argv[3]);
+    iDb = sqlite3FindDb(db, &nm);
     if( iDb<0 ){
       *pzErr = sqlite3_mprintf("no such database: %s", argv[3]);
       return SQLITE_ERROR;
@@ -164988,7 +165734,11 @@ SQLITE_EXTENSION_INIT1
 /* #include <stdlib.h> */
 /* #include <stdarg.h> */
 
-#define UNUSED_PARAM(X)  (void)(X)
+/* Mark a function parameter as unused, to suppress nuisance compiler
+** warnings. */
+#ifndef UNUSED_PARAM
+# define UNUSED_PARAM(X)  (void)(X)
+#endif
 
 #ifndef LARGEST_INT64
 # define LARGEST_INT64  (0xffffffff|(((sqlite3_int64)0x7fffffff)<<32))
@@ -165233,10 +165983,33 @@ static void jsonAppendString(JsonString *p, const char *zIn, u32 N){
   if( (N+p->nUsed+2 >= p->nAlloc) && jsonGrow(p,N+2)!=0 ) return;
   p->zBuf[p->nUsed++] = '"';
   for(i=0; i<N; i++){
-    char c = zIn[i];
+    unsigned char c = ((unsigned const char*)zIn)[i];
     if( c=='"' || c=='\\' ){
+      json_simple_escape:
       if( (p->nUsed+N+3-i > p->nAlloc) && jsonGrow(p,N+3-i)!=0 ) return;
       p->zBuf[p->nUsed++] = '\\';
+    }else if( c<=0x1f ){
+      static const char aSpecial[] = {
+         0, 0, 0, 0, 0, 0, 0, 0, 'b', 't', 'n', 0, 'f', 'r', 0, 0,
+         0, 0, 0, 0, 0, 0, 0, 0,   0,   0,   0, 0,   0,   0, 0, 0
+      };
+      assert( sizeof(aSpecial)==32 );
+      assert( aSpecial['\b']=='b' );
+      assert( aSpecial['\f']=='f' );
+      assert( aSpecial['\n']=='n' );
+      assert( aSpecial['\r']=='r' );
+      assert( aSpecial['\t']=='t' );
+      if( aSpecial[c] ){
+        c = aSpecial[c];
+        goto json_simple_escape;
+      }
+      if( (p->nUsed+N+7+i > p->nAlloc) && jsonGrow(p,N+7-i)!=0 ) return;
+      p->zBuf[p->nUsed++] = '\\';
+      p->zBuf[p->nUsed++] = 'u';
+      p->zBuf[p->nUsed++] = '0';
+      p->zBuf[p->nUsed++] = '0';
+      p->zBuf[p->nUsed++] = '0' + (c>>4);
+      c = "0123456789abcdef"[c&0xf];
     }
     p->zBuf[p->nUsed++] = c;
   }
@@ -165277,7 +166050,7 @@ static void jsonAppendValue(
     default: {
       if( p->bErr==0 ){
         sqlite3_result_error(p->pCtx, "JSON cannot hold BLOB values", -1);
-        p->bErr = 1;
+        p->bErr = 2;
         jsonReset(p);
       }
       break;
@@ -166486,6 +167259,7 @@ static void jsonArrayStep(
   sqlite3_value **argv
 ){
   JsonString *pStr;
+  UNUSED_PARAM(argc);
   pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr));
   if( pStr ){
     if( pStr->zBuf==0 ){
@@ -166505,7 +167279,7 @@ static void jsonArrayFinal(sqlite3_context *ctx){
     pStr->pCtx = ctx;
     jsonAppendChar(pStr, ']');
     if( pStr->bErr ){
-      sqlite3_result_error_nomem(ctx);
+      if( pStr->bErr==1 ) sqlite3_result_error_nomem(ctx);
       assert( pStr->bStatic );
     }else{
       sqlite3_result_text(ctx, pStr->zBuf, pStr->nUsed,
@@ -166531,6 +167305,7 @@ static void jsonObjectStep(
   JsonString *pStr;
   const char *z;
   u32 n;
+  UNUSED_PARAM(argc);
   pStr = (JsonString*)sqlite3_aggregate_context(ctx, sizeof(*pStr));
   if( pStr ){
     if( pStr->zBuf==0 ){
@@ -166553,7 +167328,7 @@ static void jsonObjectFinal(sqlite3_context *ctx){
   if( pStr ){
     jsonAppendChar(pStr, '}');
     if( pStr->bErr ){
-      sqlite3_result_error_nomem(ctx);
+      if( pStr->bErr==0 ) sqlite3_result_error_nomem(ctx);
       assert( pStr->bStatic );
     }else{
       sqlite3_result_text(ctx, pStr->zBuf, pStr->nUsed,
@@ -167218,6 +167993,9 @@ struct Fts5PhraseIter {
 **   an OOM condition or IO error), an appropriate SQLite error code is 
 **   returned.
 **
+**   This function may be quite inefficient if used with an FTS5 table
+**   created with the "columnsize=0" option.
+**
 ** xColumnText:
 **   This function attempts to retrieve the text of column iCol of the
 **   current document. If successful, (*pz) is set to point to a buffer
@@ -167238,15 +168016,29 @@ struct Fts5PhraseIter {
 **   the query within the current row. Return SQLITE_OK if successful, or
 **   an error code (i.e. SQLITE_NOMEM) if an error occurs.
 **
+**   This API can be quite slow if used with an FTS5 table created with the
+**   "detail=none" or "detail=column" option. If the FTS5 table is created 
+**   with either "detail=none" or "detail=column" and "content=" option 
+**   (i.e. if it is a contentless table), then this API always returns 0.
+**
 ** xInst:
 **   Query for the details of phrase match iIdx within the current row.
 **   Phrase matches are numbered starting from zero, so the iIdx argument
 **   should be greater than or equal to zero and smaller than the value
 **   output by xInstCount().
 **
+**   Usually, output parameter *piPhrase is set to the phrase number, *piCol
+**   to the column in which it occurs and *piOff the token offset of the
+**   first token of the phrase. The exception is if the table was created
+**   with the offsets=0 option specified. In this case *piOff is always
+**   set to -1.
+**
 **   Returns SQLITE_OK if successful, or an error code (i.e. SQLITE_NOMEM) 
 **   if an error occurs.
 **
+**   This API can be quite slow if used with an FTS5 table created with the
+**   "detail=none" or "detail=column" option. 
+**
 ** xRowid:
 **   Returns the rowid of the current row.
 **
@@ -167330,7 +168122,7 @@ struct Fts5PhraseIter {
 **       Fts5PhraseIter iter;
 **       int iCol, iOff;
 **       for(pApi->xPhraseFirst(pFts, iPhrase, &iter, &iCol, &iOff);
-**           iOff>=0;
+**           iCol>=0;
 **           pApi->xPhraseNext(pFts, &iter, &iCol, &iOff)
 **       ){
 **         // An instance of phrase iPhrase at offset iOff of column iCol
@@ -167338,13 +168130,51 @@ struct Fts5PhraseIter {
 **
 **   The Fts5PhraseIter structure is defined above. Applications should not
 **   modify this structure directly - it should only be used as shown above
-**   with the xPhraseFirst() and xPhraseNext() API methods.
+**   with the xPhraseFirst() and xPhraseNext() API methods (and by
+**   xPhraseFirstColumn() and xPhraseNextColumn() as illustrated below).
+**
+**   This API can be quite slow if used with an FTS5 table created with the
+**   "detail=none" or "detail=column" option. If the FTS5 table is created 
+**   with either "detail=none" or "detail=column" and "content=" option 
+**   (i.e. if it is a contentless table), then this API always iterates
+**   through an empty set (all calls to xPhraseFirst() set iCol to -1).
 **
 ** xPhraseNext()
 **   See xPhraseFirst above.
+**
+** xPhraseFirstColumn()
+**   This function and xPhraseNextColumn() are similar to the xPhraseFirst()
+**   and xPhraseNext() APIs described above. The difference is that instead
+**   of iterating through all instances of a phrase in the current row, these
+**   APIs are used to iterate through the set of columns in the current row
+**   that contain one or more instances of a specified phrase. For example:
+**
+**       Fts5PhraseIter iter;
+**       int iCol;
+**       for(pApi->xPhraseFirstColumn(pFts, iPhrase, &iter, &iCol);
+**           iCol>=0;
+**           pApi->xPhraseNextColumn(pFts, &iter, &iCol)
+**       ){
+**         // Column iCol contains at least one instance of phrase iPhrase
+**       }
+**
+**   This API can be quite slow if used with an FTS5 table created with the
+**   "detail=none" option. If the FTS5 table is created with either 
+**   "detail=none" "content=" option (i.e. if it is a contentless table), 
+**   then this API always iterates through an empty set (all calls to 
+**   xPhraseFirstColumn() set iCol to -1).
+**
+**   The information accessed using this API and its companion
+**   xPhraseFirstColumn() may also be obtained using xPhraseFirst/xPhraseNext
+**   (or xInst/xInstCount). The chief advantage of this API is that it is
+**   significantly more efficient than those alternatives when used with
+**   "detail=column" tables.  
+**
+** xPhraseNextColumn()
+**   See xPhraseFirstColumn above.
 */
 struct Fts5ExtensionApi {
-  int iVersion;                   /* Currently always set to 1 */
+  int iVersion;                   /* Currently always set to 3 */
 
   void *(*xUserData)(Fts5Context*);
 
@@ -167374,8 +168204,11 @@ struct Fts5ExtensionApi {
   int (*xSetAuxdata)(Fts5Context*, void *pAux, void(*xDelete)(void*));
   void *(*xGetAuxdata)(Fts5Context*, int bClear);
 
-  void (*xPhraseFirst)(Fts5Context*, int iPhrase, Fts5PhraseIter*, int*, int*);
+  int (*xPhraseFirst)(Fts5Context*, int iPhrase, Fts5PhraseIter*, int*, int*);
   void (*xPhraseNext)(Fts5Context*, Fts5PhraseIter*, int *piCol, int *piOff);
+
+  int (*xPhraseFirstColumn)(Fts5Context*, int iPhrase, Fts5PhraseIter*, int*);
+  void (*xPhraseNextColumn)(Fts5Context*, Fts5PhraseIter*, int *piCol);
 };
 
 /* 
@@ -167681,10 +168514,11 @@ SQLITE_EXTENSION_INIT1
 typedef unsigned char  u8;
 typedef unsigned int   u32;
 typedef unsigned short u16;
+typedef short i16;
 typedef sqlite3_int64 i64;
 typedef sqlite3_uint64 u64;
 
-#define ArraySize(x) (sizeof(x) / sizeof(x[0]))
+#define ArraySize(x) ((int)(sizeof(x) / sizeof(x[0])))
 
 #define testcase(x)
 #define ALWAYS(x) 1
@@ -167735,6 +168569,16 @@ SQLITE_API extern int sqlite3_fts5_may_be_corrupt;
 # define assert_nc(x) assert(x)
 #endif
 
+/* Mark a function parameter as unused, to suppress nuisance compiler
+** warnings. */
+#ifndef UNUSED_PARAM
+# define UNUSED_PARAM(X)  (void)(X)
+#endif
+
+#ifndef UNUSED_PARAM2
+# define UNUSED_PARAM2(X, Y)  (void)(X), (void)(Y)
+#endif
+
 typedef struct Fts5Global Fts5Global;
 typedef struct Fts5Colset Fts5Colset;
 
@@ -167806,6 +168650,7 @@ struct Fts5Config {
   char *zContent;                 /* content table */ 
   char *zContentRowid;            /* "content_rowid=" option value */ 
   int bColumnsize;                /* "columnsize=" option value (dflt==1) */
+  int eDetail;                    /* FTS5_DETAIL_XXX value */
   char *zContentExprlist;
   Fts5Tokenizer *pTok;
   fts5_tokenizer *pTokApi;
@@ -167834,6 +168679,9 @@ struct Fts5Config {
 #define FTS5_CONTENT_NONE     1
 #define FTS5_CONTENT_EXTERNAL 2
 
+#define FTS5_DETAIL_FULL    0
+#define FTS5_DETAIL_NONE    1
+#define FTS5_DETAIL_COLUMNS 2
 
 
 
@@ -167880,9 +168728,9 @@ struct Fts5Buffer {
   int nSpace;
 };
 
-static int sqlite3Fts5BufferSize(int*, Fts5Buffer*, int);
+static int sqlite3Fts5BufferSize(int*, Fts5Buffer*, u32);
 static void sqlite3Fts5BufferAppendVarint(int*, Fts5Buffer*, i64);
-static void sqlite3Fts5BufferAppendBlob(int*, Fts5Buffer*, int, const u8*);
+static void sqlite3Fts5BufferAppendBlob(int*, Fts5Buffer*, u32, const u8*);
 static void sqlite3Fts5BufferAppendString(int *, Fts5Buffer*, const char*);
 static void sqlite3Fts5BufferFree(Fts5Buffer*);
 static void sqlite3Fts5BufferZero(Fts5Buffer*);
@@ -167898,7 +168746,7 @@ static char *sqlite3Fts5Mprintf(int *pRc, const char *zFmt, ...);
 #define fts5BufferSet(a,b,c,d)        sqlite3Fts5BufferSet(a,b,c,d)
 
 #define fts5BufferGrow(pRc,pBuf,nn) ( \
-  (pBuf)->n + (nn) <= (pBuf)->nSpace ? 0 : \
+  (u32)((pBuf)->n) + (u32)(nn) <= (u32)((pBuf)->nSpace) ? 0 : \
     sqlite3Fts5BufferSize((pRc),(pBuf),(nn)+(pBuf)->n) \
 )
 
@@ -167933,6 +168781,7 @@ struct Fts5PoslistWriter {
   i64 iPrev;
 };
 static int sqlite3Fts5PoslistWriterAppend(Fts5Buffer*, Fts5PoslistWriter*, i64);
+static void sqlite3Fts5PoslistSafeAppend(Fts5Buffer*, i64*, i64);
 
 static int sqlite3Fts5PoslistNext64(
   const u8 *a, int n,             /* Buffer containing poslist */
@@ -167947,6 +168796,13 @@ static char *sqlite3Fts5Strndup(int *pRc, const char *pIn, int nIn);
 /* Character set tests (like isspace(), isalpha() etc.) */
 static int sqlite3Fts5IsBareword(char t);
 
+
+/* Bucket of terms object used by the integrity-check in offsets=0 mode. */
+typedef struct Fts5Termset Fts5Termset;
+static int sqlite3Fts5TermsetNew(Fts5Termset**);
+static int sqlite3Fts5TermsetAdd(Fts5Termset*, int, const char*, int, int *pbPresent);
+static void sqlite3Fts5TermsetFree(Fts5Termset*);
+
 /*
 ** End of interface to code in fts5_buffer.c.
 **************************************************************************/
@@ -167959,6 +168815,15 @@ static int sqlite3Fts5IsBareword(char t);
 typedef struct Fts5Index Fts5Index;
 typedef struct Fts5IndexIter Fts5IndexIter;
 
+struct Fts5IndexIter {
+  i64 iRowid;
+  const u8 *pData;
+  int nData;
+  u8 bEof;
+};
+
+#define sqlite3Fts5IterEof(x) ((x)->bEof)
+
 /*
 ** Values used as part of the flags argument passed to IndexQuery().
 */
@@ -167967,6 +168832,12 @@ typedef struct Fts5IndexIter Fts5IndexIter;
 #define FTS5INDEX_QUERY_TEST_NOIDX 0x0004   /* Do not use prefix index */
 #define FTS5INDEX_QUERY_SCAN       0x0008   /* Scan query (fts5vocab) */
 
+/* The following are used internally by the fts5_index.c module. They are
+** defined here only to make it easier to avoid clashes with the flags
+** above. */
+#define FTS5INDEX_QUERY_SKIPEMPTY  0x0010
+#define FTS5INDEX_QUERY_NOOUTPUT   0x0020
+
 /*
 ** Create/destroy an Fts5Index object.
 */
@@ -167974,14 +168845,27 @@ static int sqlite3Fts5IndexOpen(Fts5Config *pConfig, int bCreate, Fts5Index**, c
 static int sqlite3Fts5IndexClose(Fts5Index *p);
 
 /*
-** for(
-**   sqlite3Fts5IndexQuery(p, "token", 5, 0, 0, &pIter);
-**   0==sqlite3Fts5IterEof(pIter);
-**   sqlite3Fts5IterNext(pIter)
-** ){
-**   i64 iRowid = sqlite3Fts5IterRowid(pIter);
-** }
+** Return a simple checksum value based on the arguments.
 */
+static u64 sqlite3Fts5IndexEntryCksum(
+  i64 iRowid, 
+  int iCol, 
+  int iPos, 
+  int iIdx,
+  const char *pTerm,
+  int nTerm
+);
+
+/*
+** Argument p points to a buffer containing utf-8 text that is n bytes in 
+** size. Return the number of bytes in the nChar character prefix of the
+** buffer, or 0 if there are less than nChar characters in total.
+*/
+static int sqlite3Fts5IndexCharlenToBytelen(
+  const char *p, 
+  int nByte, 
+  int nChar
+);
 
 /*
 ** Open a new iterator to iterate though all rowids that match the 
@@ -167999,12 +168883,8 @@ static int sqlite3Fts5IndexQuery(
 ** The various operations on open token or token prefix iterators opened
 ** using sqlite3Fts5IndexQuery().
 */
-static int sqlite3Fts5IterEof(Fts5IndexIter*);
 static int sqlite3Fts5IterNext(Fts5IndexIter*);
 static int sqlite3Fts5IterNextFrom(Fts5IndexIter*, i64 iMatch);
-static i64 sqlite3Fts5IterRowid(Fts5IndexIter*);
-static int sqlite3Fts5IterPoslist(Fts5IndexIter*,Fts5Colset*, const u8**, int*, i64*);
-static int sqlite3Fts5IterPoslistBuffer(Fts5IndexIter *pIter, Fts5Buffer *pBuf);
 
 /*
 ** Close an iterator opened by sqlite3Fts5IndexQuery().
@@ -168068,7 +168948,6 @@ static int sqlite3Fts5IndexSetAverages(Fts5Index *p, const u8*, int);
 /*
 ** Functions called by the storage module as part of integrity-check.
 */
-static u64 sqlite3Fts5IndexCksum(Fts5Config*,i64,int,int,const char*,int);
 static int sqlite3Fts5IndexIntegrityCheck(Fts5Index*, u64 cksum);
 
 /* 
@@ -168147,7 +169026,7 @@ typedef struct Fts5Hash Fts5Hash;
 /*
 ** Create a hash table, free a hash table.
 */
-static int sqlite3Fts5HashNew(Fts5Hash**, int *pnSize);
+static int sqlite3Fts5HashNew(Fts5Config*, Fts5Hash**, int *pnSize);
 static void sqlite3Fts5HashFree(Fts5Hash*);
 
 static int sqlite3Fts5HashWrite(
@@ -168206,7 +169085,7 @@ static int sqlite3Fts5StorageRename(Fts5Storage*, const char *zName);
 static int sqlite3Fts5DropAll(Fts5Config*);
 static int sqlite3Fts5CreateTable(Fts5Config*, const char*, const char*, int, char **);
 
-static int sqlite3Fts5StorageDelete(Fts5Storage *p, i64);
+static int sqlite3Fts5StorageDelete(Fts5Storage *p, i64, sqlite3_value**);
 static int sqlite3Fts5StorageContentInsert(Fts5Storage *p, sqlite3_value**, i64*);
 static int sqlite3Fts5StorageIndexInsert(Fts5Storage *p, sqlite3_value**, i64);
 
@@ -168226,8 +169105,6 @@ static int sqlite3Fts5StorageConfigValue(
     Fts5Storage *p, const char*, sqlite3_value*, int
 );
 
-static int sqlite3Fts5StorageSpecialDelete(Fts5Storage *p, i64 iDel, sqlite3_value**);
-
 static int sqlite3Fts5StorageDeleteAll(Fts5Storage *p);
 static int sqlite3Fts5StorageRebuild(Fts5Storage *p);
 static int sqlite3Fts5StorageOptimize(Fts5Storage *p);
@@ -168284,7 +169161,17 @@ static int sqlite3Fts5ExprPhraseCount(Fts5Expr*);
 static int sqlite3Fts5ExprPhraseSize(Fts5Expr*, int iPhrase);
 static int sqlite3Fts5ExprPoslist(Fts5Expr*, int, const u8 **);
 
-static int sqlite3Fts5ExprClonePhrase(Fts5Config*, Fts5Expr*, int, Fts5Expr**);
+typedef struct Fts5PoslistPopulator Fts5PoslistPopulator;
+static Fts5PoslistPopulator *sqlite3Fts5ExprClearPoslists(Fts5Expr*, int);
+static int sqlite3Fts5ExprPopulatePoslists(
+    Fts5Config*, Fts5Expr*, Fts5PoslistPopulator*, int, const char*, int
+);
+static void sqlite3Fts5ExprCheckPoslists(Fts5Expr*, i64);
+static void sqlite3Fts5ExprClearEof(Fts5Expr*);
+
+static int sqlite3Fts5ExprClonePhrase(Fts5Expr*, int, Fts5Expr**);
+
+static int sqlite3Fts5ExprPhraseCollist(Fts5Expr *, int, const u8 **, int *);
 
 /*******************************************
 ** The fts5_expr.c API above this point is used by the other hand-written
@@ -169073,7 +169960,8 @@ static void fts5yyStackOverflow(fts5yyParser *fts5yypParser, fts5YYMINORTYPE *ft
    ** stack every overflows */
 /******** Begin %stack_overflow code ******************************************/
 
-  assert( 0 );
+  UNUSED_PARAM(fts5yypMinor); /* Silence a compiler warning */
+  sqlite3Fts5ParseError(pParse, "fts5: parser stack overflow");
 /******** End %stack_overflow code ********************************************/
    sqlite3Fts5ParserARG_STORE; /* Suppress warning about unused %extra_argument var */
 }
@@ -169370,6 +170258,7 @@ static void fts5yy_syntax_error(
 #define FTS5TOKEN (fts5yyminor.fts5yy0)
 /************ Begin %syntax_error code ****************************************/
 
+  UNUSED_PARAM(fts5yymajor); /* Silence a compiler warning */
   sqlite3Fts5ParseError(
     pParse, "fts5: syntax error near \"%.*s\"",FTS5TOKEN.n,FTS5TOKEN.p
   );
@@ -169747,6 +170636,8 @@ static int fts5HighlightCb(
   int rc = SQLITE_OK;
   int iPos;
 
+  UNUSED_PARAM2(pToken, nToken);
+
   if( tflags & FTS5_TOKEN_COLOCATED ) return SQLITE_OK;
   iPos = p->iPos++;
 
@@ -169980,6 +170871,7 @@ static int fts5CountCb(
   void *pUserData                 /* Pointer to sqlite3_int64 variable */
 ){
   sqlite3_int64 *pn = (sqlite3_int64*)pUserData;
+  UNUSED_PARAM2(pApi, pFts);
   (*pn)++;
   return SQLITE_OK;
 }
@@ -170133,7 +171025,7 @@ static int sqlite3Fts5AuxInit(fts5_api *pApi){
   int rc = SQLITE_OK;             /* Return code */
   int i;                          /* To iterate through builtin functions */
 
-  for(i=0; rc==SQLITE_OK && i<(int)ArraySize(aBuiltin); i++){
+  for(i=0; rc==SQLITE_OK && i<ArraySize(aBuiltin); i++){
     rc = pApi->xCreateFunction(pApi,
         aBuiltin[i].zFunc,
         aBuiltin[i].pUserData,
@@ -170164,19 +171056,21 @@ static int sqlite3Fts5AuxInit(fts5_api *pApi){
 
 /* #include "fts5Int.h" */
 
-static int sqlite3Fts5BufferSize(int *pRc, Fts5Buffer *pBuf, int nByte){
-  int nNew = pBuf->nSpace ? pBuf->nSpace*2 : 64;
-  u8 *pNew;
-  while( nNew<nByte ){
-    nNew = nNew * 2;
-  }
-  pNew = sqlite3_realloc(pBuf->p, nNew);
-  if( pNew==0 ){
-    *pRc = SQLITE_NOMEM;
-    return 1;
-  }else{
-    pBuf->nSpace = nNew;
-    pBuf->p = pNew;
+static int sqlite3Fts5BufferSize(int *pRc, Fts5Buffer *pBuf, u32 nByte){
+  if( (u32)pBuf->nSpace<nByte ){
+    u32 nNew = pBuf->nSpace ? pBuf->nSpace : 64;
+    u8 *pNew;
+    while( nNew<nByte ){
+      nNew = nNew * 2;
+    }
+    pNew = sqlite3_realloc(pBuf->p, nNew);
+    if( pNew==0 ){
+      *pRc = SQLITE_NOMEM;
+      return 1;
+    }else{
+      pBuf->nSpace = nNew;
+      pBuf->p = pNew;
+    }
   }
   return 0;
 }
@@ -170210,10 +171104,10 @@ static int sqlite3Fts5Get32(const u8 *aBuf){
 static void sqlite3Fts5BufferAppendBlob(
   int *pRc,
   Fts5Buffer *pBuf, 
-  int nData, 
+  u32 nData, 
   const u8 *pData
 ){
-  assert( *pRc || nData>=0 );
+  assert_nc( *pRc || nData>=0 );
   if( fts5BufferGrow(pRc, pBuf, nData) ) return;
   memcpy(&pBuf->p[pBuf->n], pData, nData);
   pBuf->n += nData;
@@ -170357,23 +171251,36 @@ static int sqlite3Fts5PoslistReaderInit(
   return pIter->bEof;
 }
 
+/*
+** Append position iPos to the position list being accumulated in buffer
+** pBuf, which must be already be large enough to hold the new data.
+** The previous position written to this list is *piPrev. *piPrev is set
+** to iPos before returning.
+*/
+static void sqlite3Fts5PoslistSafeAppend(
+  Fts5Buffer *pBuf, 
+  i64 *piPrev, 
+  i64 iPos
+){
+  static const i64 colmask = ((i64)(0x7FFFFFFF)) << 32;
+  if( (iPos & colmask) != (*piPrev & colmask) ){
+    pBuf->p[pBuf->n++] = 1;
+    pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos>>32));
+    *piPrev = (iPos & colmask);
+  }
+  pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos-*piPrev)+2);
+  *piPrev = iPos;
+}
+
 static int sqlite3Fts5PoslistWriterAppend(
   Fts5Buffer *pBuf, 
   Fts5PoslistWriter *pWriter,
   i64 iPos
 ){
-  static const i64 colmask = ((i64)(0x7FFFFFFF)) << 32;
-  int rc = SQLITE_OK;
-  if( 0==fts5BufferGrow(&rc, pBuf, 5+5+5) ){
-    if( (iPos & colmask) != (pWriter->iPrev & colmask) ){
-      pBuf->p[pBuf->n++] = 1;
-      pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos>>32));
-      pWriter->iPrev = (iPos & colmask);
-    }
-    pBuf->n += sqlite3Fts5PutVarint(&pBuf->p[pBuf->n], (iPos-pWriter->iPrev)+2);
-    pWriter->iPrev = iPos;
-  }
-  return rc;
+  int rc = 0;   /* Initialized only to suppress erroneous warning from Clang */
+  if( fts5BufferGrow(&rc, pBuf, 5+5+5) ) return rc;
+  sqlite3Fts5PoslistSafeAppend(pBuf, &pWriter->iPrev, iPos);
+  return SQLITE_OK;
 }
 
 static void *sqlite3Fts5MallocZero(int *pRc, int nByte){
@@ -170441,6 +171348,89 @@ static int sqlite3Fts5IsBareword(char t){
 }
 
 
+/*************************************************************************
+*/
+typedef struct Fts5TermsetEntry Fts5TermsetEntry;
+struct Fts5TermsetEntry {
+  char *pTerm;
+  int nTerm;
+  int iIdx;                       /* Index (main or aPrefix[] entry) */
+  Fts5TermsetEntry *pNext;
+};
+
+struct Fts5Termset {
+  Fts5TermsetEntry *apHash[512];
+};
+
+static int sqlite3Fts5TermsetNew(Fts5Termset **pp){
+  int rc = SQLITE_OK;
+  *pp = sqlite3Fts5MallocZero(&rc, sizeof(Fts5Termset));
+  return rc;
+}
+
+static int sqlite3Fts5TermsetAdd(
+  Fts5Termset *p, 
+  int iIdx,
+  const char *pTerm, int nTerm, 
+  int *pbPresent
+){
+  int rc = SQLITE_OK;
+  *pbPresent = 0;
+  if( p ){
+    int i;
+    u32 hash = 13;
+    Fts5TermsetEntry *pEntry;
+
+    /* Calculate a hash value for this term. This is the same hash checksum
+    ** used by the fts5_hash.c module. This is not important for correct
+    ** operation of the module, but is necessary to ensure that some tests
+    ** designed to produce hash table collisions really do work.  */
+    for(i=nTerm-1; i>=0; i--){
+      hash = (hash << 3) ^ hash ^ pTerm[i];
+    }
+    hash = (hash << 3) ^ hash ^ iIdx;
+    hash = hash % ArraySize(p->apHash);
+
+    for(pEntry=p->apHash[hash]; pEntry; pEntry=pEntry->pNext){
+      if( pEntry->iIdx==iIdx 
+          && pEntry->nTerm==nTerm 
+          && memcmp(pEntry->pTerm, pTerm, nTerm)==0 
+      ){
+        *pbPresent = 1;
+        break;
+      }
+    }
+
+    if( pEntry==0 ){
+      pEntry = sqlite3Fts5MallocZero(&rc, sizeof(Fts5TermsetEntry) + nTerm);
+      if( pEntry ){
+        pEntry->pTerm = (char*)&pEntry[1];
+        pEntry->nTerm = nTerm;
+        pEntry->iIdx = iIdx;
+        memcpy(pEntry->pTerm, pTerm, nTerm);
+        pEntry->pNext = p->apHash[hash];
+        p->apHash[hash] = pEntry;
+      }
+    }
+  }
+
+  return rc;
+}
+
+static void sqlite3Fts5TermsetFree(Fts5Termset *p){
+  if( p ){
+    u32 i;
+    for(i=0; i<ArraySize(p->apHash); i++){
+      Fts5TermsetEntry *pEntry = p->apHash[i];
+      while( pEntry ){
+        Fts5TermsetEntry *pDel = pEntry;
+        pEntry = pEntry->pNext;
+        sqlite3_free(pDel);
+      }
+    }
+    sqlite3_free(p);
+  }
+}
 
 /*
 ** 2014 Jun 09
@@ -170458,7 +171448,6 @@ static int sqlite3Fts5IsBareword(char t){
 */
 
 
-
 /* #include "fts5Int.h" */
 
 #define FTS5_DEFAULT_PAGE_SIZE   4050
@@ -170639,6 +171628,33 @@ static void sqlite3Fts5Dequote(char *z){
   }
 }
 
+
+struct Fts5Enum {
+  const char *zName;
+  int eVal;
+};
+typedef struct Fts5Enum Fts5Enum;
+
+static int fts5ConfigSetEnum(
+  const Fts5Enum *aEnum, 
+  const char *zEnum, 
+  int *peVal
+){
+  int nEnum = (int)strlen(zEnum);
+  int i;
+  int iVal = -1;
+
+  for(i=0; aEnum[i].zName; i++){
+    if( sqlite3_strnicmp(aEnum[i].zName, zEnum, nEnum)==0 ){
+      if( iVal>=0 ) return SQLITE_ERROR;
+      iVal = aEnum[i].eVal;
+    }
+  }
+
+  *peVal = iVal;
+  return iVal<0 ? SQLITE_ERROR : SQLITE_OK;
+}
+
 /*
 ** Parse a "special" CREATE VIRTUAL TABLE directive and update
 ** configuration object pConfig as appropriate.
@@ -170696,7 +171712,7 @@ static int fts5ConfigParseSpecial(
         p++;
       }
 
-      if( rc==SQLITE_OK && (nPre<=0 || nPre>=1000) ){
+      if( nPre<=0 || nPre>=1000 ){
         *pzErr = sqlite3_mprintf("prefix length out of range (max 999)");
         rc = SQLITE_ERROR;
         break;
@@ -170789,6 +171805,20 @@ static int fts5ConfigParseSpecial(
     return rc;
   }
 
+  if( sqlite3_strnicmp("detail", zCmd, nCmd)==0 ){
+    const Fts5Enum aDetail[] = {
+      { "none", FTS5_DETAIL_NONE },
+      { "full", FTS5_DETAIL_FULL },
+      { "columns", FTS5_DETAIL_COLUMNS },
+      { 0, 0 }
+    };
+
+    if( (rc = fts5ConfigSetEnum(aDetail, zArg, &pConfig->eDetail)) ){
+      *pzErr = sqlite3_mprintf("malformed detail=... directive");
+    }
+    return rc;
+  }
+
   *pzErr = sqlite3_mprintf("unrecognized option: \"%.*s\"", nCmd, zCmd);
   return SQLITE_ERROR;
 }
@@ -170944,6 +171974,7 @@ static int sqlite3Fts5ConfigParse(
   pRet->zDb = sqlite3Fts5Strndup(&rc, azArg[1], -1);
   pRet->zName = sqlite3Fts5Strndup(&rc, azArg[2], -1);
   pRet->bColumnsize = 1;
+  pRet->eDetail = FTS5_DETAIL_FULL;
 #ifdef SQLITE_DEBUG
   pRet->bPrefixIndex = 1;
 #endif
@@ -171347,7 +172378,6 @@ static int sqlite3Fts5ConfigLoad(Fts5Config *pConfig, int iCookie){
   return rc;
 }
 
-
 /*
 ** 2014 May 31
 **
@@ -171390,6 +172420,7 @@ static void sqlite3Fts5ParserTrace(FILE*, char*);
 
 struct Fts5Expr {
   Fts5Index *pIndex;
+  Fts5Config *pConfig;
   Fts5ExprNode *pRoot;
   int bDesc;                      /* Iterate in descending rowid order */
   int nPhrase;                    /* Number of phrases in expression */
@@ -171411,6 +172442,9 @@ struct Fts5ExprNode {
   int bEof;                       /* True at EOF */
   int bNomatch;                   /* True if entry is not a match */
 
+  /* Next method for this node. */
+  int (*xNext)(Fts5Expr*, Fts5ExprNode*, int, i64);
+
   i64 iRowid;                     /* Current rowid */
   Fts5ExprNearset *pNear;         /* For FTS5_STRING - cluster of phrases */
 
@@ -171422,6 +172456,12 @@ struct Fts5ExprNode {
 
 #define Fts5NodeIsString(p) ((p)->eType==FTS5_TERM || (p)->eType==FTS5_STRING)
 
+/*
+** Invoke the xNext method of an Fts5ExprNode object. This macro should be
+** used as if it has the same signature as the xNext() methods themselves.
+*/
+#define fts5ExprNodeNext(a,b,c,d) (b)->xNext((a), (b), (c), (d))
+
 /*
 ** An instance of the following structure represents a single search term
 ** or term prefix.
@@ -171583,8 +172623,17 @@ static int sqlite3Fts5ExprNew(
       sParse.rc = SQLITE_NOMEM;
       sqlite3Fts5ParseNodeFree(sParse.pExpr);
     }else{
-      pNew->pRoot = sParse.pExpr;
+      if( !sParse.pExpr ){
+        const int nByte = sizeof(Fts5ExprNode);
+        pNew->pRoot = (Fts5ExprNode*)sqlite3Fts5MallocZero(&sParse.rc, nByte);
+        if( pNew->pRoot ){
+          pNew->pRoot->bEof = 1;
+        }
+      }else{
+        pNew->pRoot = sParse.pExpr;
+      }
       pNew->pIndex = 0;
+      pNew->pConfig = pConfig;
       pNew->apExprPhrase = sParse.apPhrase;
       pNew->nPhrase = sParse.nPhrase;
       sParse.apPhrase = 0;
@@ -171634,7 +172683,7 @@ static i64 fts5ExprSynonymRowid(Fts5ExprTerm *pTerm, int bDesc, int *pbEof){
   assert( bDesc==0 || bDesc==1 );
   for(p=pTerm; p; p=p->pSynonym){
     if( 0==sqlite3Fts5IterEof(p->pIter) ){
-      i64 iRowid = sqlite3Fts5IterRowid(p->pIter);
+      i64 iRowid = p->pIter->iRowid;
       if( bRetValid==0 || (bDesc!=(iRowid<iRet)) ){
         iRet = iRowid;
         bRetValid = 1;
@@ -171649,11 +172698,10 @@ static i64 fts5ExprSynonymRowid(Fts5ExprTerm *pTerm, int bDesc, int *pbEof){
 /*
 ** Argument pTerm must be a synonym iterator.
 */
-static int fts5ExprSynonymPoslist(
+static int fts5ExprSynonymList(
   Fts5ExprTerm *pTerm, 
-  Fts5Colset *pColset,
   i64 iRowid,
-  int *pbDel,                     /* OUT: Caller should sqlite3_free(*pa) */
+  Fts5Buffer *pBuf,               /* Use this buffer for space if required */
   u8 **pa, int *pn
 ){
   Fts5PoslistReader aStatic[4];
@@ -171666,12 +172714,8 @@ static int fts5ExprSynonymPoslist(
   assert( pTerm->pSynonym );
   for(p=pTerm; p; p=p->pSynonym){
     Fts5IndexIter *pIter = p->pIter;
-    if( sqlite3Fts5IterEof(pIter)==0 && sqlite3Fts5IterRowid(pIter)==iRowid ){
-      const u8 *a;
-      int n;
-      i64 dummy;
-      rc = sqlite3Fts5IterPoslist(pIter, pColset, &a, &n, &dummy);
-      if( rc!=SQLITE_OK ) goto synonym_poslist_out;
+    if( sqlite3Fts5IterEof(pIter)==0 && pIter->iRowid==iRowid ){
+      if( pIter->nData==0 ) continue;
       if( nIter==nAlloc ){
         int nByte = sizeof(Fts5PoslistReader) * nAlloc * 2;
         Fts5PoslistReader *aNew = (Fts5PoslistReader*)sqlite3_malloc(nByte);
@@ -171684,20 +172728,19 @@ static int fts5ExprSynonymPoslist(
         if( aIter!=aStatic ) sqlite3_free(aIter);
         aIter = aNew;
       }
-      sqlite3Fts5PoslistReaderInit(a, n, &aIter[nIter]);
+      sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &aIter[nIter]);
       assert( aIter[nIter].bEof==0 );
       nIter++;
     }
   }
 
-  assert( *pbDel==0 );
   if( nIter==1 ){
     *pa = (u8*)aIter[0].a;
     *pn = aIter[0].n;
   }else{
     Fts5PoslistWriter writer = {0};
-    Fts5Buffer buf = {0,0,0};
     i64 iPrev = -1;
+    fts5BufferZero(pBuf);
     while( 1 ){
       int i;
       i64 iMin = FTS5_LARGEST_INT64;
@@ -171712,15 +172755,12 @@ static int fts5ExprSynonymPoslist(
         }
       }
       if( iMin==FTS5_LARGEST_INT64 || rc!=SQLITE_OK ) break;
-      rc = sqlite3Fts5PoslistWriterAppend(&buf, &writer, iMin);
+      rc = sqlite3Fts5PoslistWriterAppend(pBuf, &writer, iMin);
       iPrev = iMin;
     }
-    if( rc ){
-      sqlite3_free(buf.p);
-    }else{
-      *pa = buf.p;
-      *pn = buf.n;
-      *pbDel = 1;
+    if( rc==SQLITE_OK ){
+      *pa = pBuf->p;
+      *pn = pBuf->n;
     }
   }
 
@@ -171743,7 +172783,6 @@ static int fts5ExprSynonymPoslist(
 */
 static int fts5ExprPhraseIsMatch(
   Fts5ExprNode *pNode,            /* Node pPhrase belongs to */
-  Fts5Colset *pColset,            /* Restrict matches to these columns */
   Fts5ExprPhrase *pPhrase,        /* Phrase object to initialize */
   int *pbMatch                    /* OUT: Set to true if really a match */
 ){
@@ -171757,7 +172796,7 @@ static int fts5ExprPhraseIsMatch(
 
   /* If the aStatic[] array is not large enough, allocate a large array
   ** using sqlite3_malloc(). This approach could be improved upon. */
-  if( pPhrase->nTerm>(int)ArraySize(aStatic) ){
+  if( pPhrase->nTerm>ArraySize(aStatic) ){
     int nByte = sizeof(Fts5PoslistReader) * pPhrase->nTerm;
     aIter = (Fts5PoslistReader*)sqlite3_malloc(nByte);
     if( !aIter ) return SQLITE_NOMEM;
@@ -171767,18 +172806,21 @@ static int fts5ExprPhraseIsMatch(
   /* Initialize a term iterator for each term in the phrase */
   for(i=0; i<pPhrase->nTerm; i++){
     Fts5ExprTerm *pTerm = &pPhrase->aTerm[i];
-    i64 dummy;
     int n = 0;
     int bFlag = 0;
-    const u8 *a = 0;
+    u8 *a = 0;
     if( pTerm->pSynonym ){
-      rc = fts5ExprSynonymPoslist(
-          pTerm, pColset, pNode->iRowid, &bFlag, (u8**)&a, &n
-      );
+      Fts5Buffer buf = {0, 0, 0};
+      rc = fts5ExprSynonymList(pTerm, pNode->iRowid, &buf, &a, &n);
+      if( rc ){
+        sqlite3_free(a);
+        goto ismatch_out;
+      }
+      if( a==buf.p ) bFlag = 1;
     }else{
-      rc = sqlite3Fts5IterPoslist(pTerm->pIter, pColset, &a, &n, &dummy);
+      a = (u8*)pTerm->pIter->pData;
+      n = pTerm->pIter->nData;
     }
-    if( rc!=SQLITE_OK ) goto ismatch_out;
     sqlite3Fts5PoslistReaderInit(a, n, &aIter[i]);
     aIter[i].bFlag = (u8)bFlag;
     if( aIter[i].bEof ) goto ismatch_out;
@@ -171850,12 +172892,6 @@ static int fts5LookaheadReaderInit(
   return fts5LookaheadReaderNext(p);
 }
 
-#if 0
-static int fts5LookaheadReaderEof(Fts5LookaheadReader *p){
-  return (p->iPos==FTS5_LOOKAHEAD_EOF);
-}
-#endif
-
 typedef struct Fts5NearTrimmer Fts5NearTrimmer;
 struct Fts5NearTrimmer {
   Fts5LookaheadReader reader;     /* Input iterator */
@@ -171893,7 +172929,7 @@ static int fts5ExprNearIsMatch(int *pRc, Fts5ExprNearset *pNear){
 
   /* If the aStatic[] array is not large enough, allocate a large array
   ** using sqlite3_malloc(). This approach could be improved upon. */
-  if( pNear->nPhrase>(int)ArraySize(aStatic) ){
+  if( pNear->nPhrase>ArraySize(aStatic) ){
     int nByte = sizeof(Fts5NearTrimmer) * pNear->nPhrase;
     a = (Fts5NearTrimmer*)sqlite3Fts5MallocZero(&rc, nByte);
   }else{
@@ -171970,71 +173006,6 @@ static int fts5ExprNearIsMatch(int *pRc, Fts5ExprNearset *pNear){
   }
 }
 
-/*
-** Advance the first term iterator in the first phrase of pNear. Set output
-** variable *pbEof to true if it reaches EOF or if an error occurs.
-**
-** Return SQLITE_OK if successful, or an SQLite error code if an error
-** occurs.
-*/
-static int fts5ExprNearAdvanceFirst(
-  Fts5Expr *pExpr,                /* Expression pPhrase belongs to */
-  Fts5ExprNode *pNode,            /* FTS5_STRING or FTS5_TERM node */
-  int bFromValid,
-  i64 iFrom 
-){
-  Fts5ExprTerm *pTerm = &pNode->pNear->apPhrase[0]->aTerm[0];
-  int rc = SQLITE_OK;
-
-  if( pTerm->pSynonym ){
-    int bEof = 1;
-    Fts5ExprTerm *p;
-
-    /* Find the firstest rowid any synonym points to. */
-    i64 iRowid = fts5ExprSynonymRowid(pTerm, pExpr->bDesc, 0);
-
-    /* Advance each iterator that currently points to iRowid. Or, if iFrom
-    ** is valid - each iterator that points to a rowid before iFrom.  */
-    for(p=pTerm; p; p=p->pSynonym){
-      if( sqlite3Fts5IterEof(p->pIter)==0 ){
-        i64 ii = sqlite3Fts5IterRowid(p->pIter);
-        if( ii==iRowid 
-         || (bFromValid && ii!=iFrom && (ii>iFrom)==pExpr->bDesc) 
-        ){
-          if( bFromValid ){
-            rc = sqlite3Fts5IterNextFrom(p->pIter, iFrom);
-          }else{
-            rc = sqlite3Fts5IterNext(p->pIter);
-          }
-          if( rc!=SQLITE_OK ) break;
-          if( sqlite3Fts5IterEof(p->pIter)==0 ){
-            bEof = 0;
-          }
-        }else{
-          bEof = 0;
-        }
-      }
-    }
-
-    /* Set the EOF flag if either all synonym iterators are at EOF or an
-    ** error has occurred.  */
-    pNode->bEof = (rc || bEof);
-  }else{
-    Fts5IndexIter *pIter = pTerm->pIter;
-
-    assert( Fts5NodeIsString(pNode) );
-    if( bFromValid ){
-      rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
-    }else{
-      rc = sqlite3Fts5IterNext(pIter);
-    }
-
-    pNode->bEof = (rc || sqlite3Fts5IterEof(pIter));
-  }
-
-  return rc;
-}
-
 /*
 ** Advance iterator pIter until it points to a value equal to or laster
 ** than the initial value of *piLast. If this means the iterator points
@@ -172054,7 +173025,7 @@ static int fts5ExprAdvanceto(
   i64 iLast = *piLast;
   i64 iRowid;
 
-  iRowid = sqlite3Fts5IterRowid(pIter);
+  iRowid = pIter->iRowid;
   if( (bDesc==0 && iLast>iRowid) || (bDesc && iLast<iRowid) ){
     int rc = sqlite3Fts5IterNextFrom(pIter, iLast);
     if( rc || sqlite3Fts5IterEof(pIter) ){
@@ -172062,7 +173033,7 @@ static int fts5ExprAdvanceto(
       *pbEof = 1;
       return 1;
     }
-    iRowid = sqlite3Fts5IterRowid(pIter);
+    iRowid = pIter->iRowid;
     assert( (bDesc==0 && iRowid>=iLast) || (bDesc==1 && iRowid<=iLast) );
   }
   *piLast = iRowid;
@@ -172083,7 +173054,7 @@ static int fts5ExprSynonymAdvanceto(
 
   for(p=pTerm; rc==SQLITE_OK && p; p=p->pSynonym){
     if( sqlite3Fts5IterEof(p->pIter)==0 ){
-      i64 iRowid = sqlite3Fts5IterRowid(p->pIter);
+      i64 iRowid = p->pIter->iRowid;
       if( (bDesc==0 && iLast>iRowid) || (bDesc && iLast<iRowid) ){
         rc = sqlite3Fts5IterNextFrom(p->pIter, iLast);
       }
@@ -172107,130 +173078,47 @@ static int fts5ExprNearTest(
 ){
   Fts5ExprNearset *pNear = pNode->pNear;
   int rc = *pRc;
-  int i;
 
-  /* Check that each phrase in the nearset matches the current row.
-  ** Populate the pPhrase->poslist buffers at the same time. If any
-  ** phrase is not a match, break out of the loop early.  */
-  for(i=0; rc==SQLITE_OK && i<pNear->nPhrase; i++){
-    Fts5ExprPhrase *pPhrase = pNear->apPhrase[i];
-    if( pPhrase->nTerm>1 || pPhrase->aTerm[0].pSynonym || pNear->pColset ){
-      int bMatch = 0;
-      rc = fts5ExprPhraseIsMatch(pNode, pNear->pColset, pPhrase, &bMatch);
-      if( bMatch==0 ) break;
-    }else{
-      rc = sqlite3Fts5IterPoslistBuffer(
-          pPhrase->aTerm[0].pIter, &pPhrase->poslist
-      );
-    }
-  }
-
-  *pRc = rc;
-  if( i==pNear->nPhrase && (i==1 || fts5ExprNearIsMatch(pRc, pNear)) ){
-    return 1;
-  }
-
-  return 0;
-}
-
-static int fts5ExprTokenTest(
-  Fts5Expr *pExpr,                /* Expression that pNear is a part of */
-  Fts5ExprNode *pNode             /* The "NEAR" node (FTS5_TERM) */
-){
-  /* As this "NEAR" object is actually a single phrase that consists 
-  ** of a single term only, grab pointers into the poslist managed by the
-  ** fts5_index.c iterator object. This is much faster than synthesizing 
-  ** a new poslist the way we have to for more complicated phrase or NEAR
-  ** expressions.  */
-  Fts5ExprNearset *pNear = pNode->pNear;
-  Fts5ExprPhrase *pPhrase = pNear->apPhrase[0];
-  Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
-  Fts5Colset *pColset = pNear->pColset;
-  int rc;
-
-  assert( pNode->eType==FTS5_TERM );
-  assert( pNear->nPhrase==1 && pPhrase->nTerm==1 );
-  assert( pPhrase->aTerm[0].pSynonym==0 );
-
-  rc = sqlite3Fts5IterPoslist(pIter, pColset, 
-      (const u8**)&pPhrase->poslist.p, &pPhrase->poslist.n, &pNode->iRowid
-  );
-  pNode->bNomatch = (pPhrase->poslist.n==0);
-  return rc;
-}
-
-/*
-** All individual term iterators in pNear are guaranteed to be valid when
-** this function is called. This function checks if all term iterators
-** point to the same rowid, and if not, advances them until they do.
-** If an EOF is reached before this happens, *pbEof is set to true before
-** returning.
-**
-** SQLITE_OK is returned if an error occurs, or an SQLite error code 
-** otherwise. It is not considered an error code if an iterator reaches
-** EOF.
-*/
-static int fts5ExprNearNextMatch(
-  Fts5Expr *pExpr,                /* Expression pPhrase belongs to */
-  Fts5ExprNode *pNode
-){
-  Fts5ExprNearset *pNear = pNode->pNear;
-  Fts5ExprPhrase *pLeft = pNear->apPhrase[0];
-  int rc = SQLITE_OK;
-  i64 iLast;                      /* Lastest rowid any iterator points to */
-  int i, j;                       /* Phrase and token index, respectively */
-  int bMatch;                     /* True if all terms are at the same rowid */
-  const int bDesc = pExpr->bDesc;
-
-  /* Check that this node should not be FTS5_TERM */
-  assert( pNear->nPhrase>1 
-       || pNear->apPhrase[0]->nTerm>1 
-       || pNear->apPhrase[0]->aTerm[0].pSynonym
-  );
-
-  /* Initialize iLast, the "lastest" rowid any iterator points to. If the
-  ** iterator skips through rowids in the default ascending order, this means
-  ** the maximum rowid. Or, if the iterator is "ORDER BY rowid DESC", then it
-  ** means the minimum rowid.  */
-  if( pLeft->aTerm[0].pSynonym ){
-    iLast = fts5ExprSynonymRowid(&pLeft->aTerm[0], bDesc, 0);
-  }else{
-    iLast = sqlite3Fts5IterRowid(pLeft->aTerm[0].pIter);
-  }
-
-  do {
-    bMatch = 1;
-    for(i=0; i<pNear->nPhrase; i++){
-      Fts5ExprPhrase *pPhrase = pNear->apPhrase[i];
-      for(j=0; j<pPhrase->nTerm; j++){
-        Fts5ExprTerm *pTerm = &pPhrase->aTerm[j];
-        if( pTerm->pSynonym ){
-          i64 iRowid = fts5ExprSynonymRowid(pTerm, bDesc, 0);
-          if( iRowid==iLast ) continue;
-          bMatch = 0;
-          if( fts5ExprSynonymAdvanceto(pTerm, bDesc, &iLast, &rc) ){
-            pNode->bEof = 1;
-            return rc;
-          }
-        }else{
-          Fts5IndexIter *pIter = pPhrase->aTerm[j].pIter;
-          i64 iRowid = sqlite3Fts5IterRowid(pIter);
-          if( iRowid==iLast ) continue;
-          bMatch = 0;
-          if( fts5ExprAdvanceto(pIter, bDesc, &iLast, &rc, &pNode->bEof) ){
-            return rc;
-          }
+  if( pExpr->pConfig->eDetail!=FTS5_DETAIL_FULL ){
+    Fts5ExprTerm *pTerm;
+    Fts5ExprPhrase *pPhrase = pNear->apPhrase[0];
+    pPhrase->poslist.n = 0;
+    for(pTerm=&pPhrase->aTerm[0]; pTerm; pTerm=pTerm->pSynonym){
+      Fts5IndexIter *pIter = pTerm->pIter;
+      if( sqlite3Fts5IterEof(pIter)==0 ){
+        if( pIter->iRowid==pNode->iRowid && pIter->nData>0 ){
+          pPhrase->poslist.n = 1;
         }
       }
     }
-  }while( bMatch==0 );
+    return pPhrase->poslist.n;
+  }else{
+    int i;
 
-  pNode->iRowid = iLast;
-  pNode->bNomatch = (0==fts5ExprNearTest(&rc, pExpr, pNode));
+    /* Check that each phrase in the nearset matches the current row.
+    ** Populate the pPhrase->poslist buffers at the same time. If any
+    ** phrase is not a match, break out of the loop early.  */
+    for(i=0; rc==SQLITE_OK && i<pNear->nPhrase; i++){
+      Fts5ExprPhrase *pPhrase = pNear->apPhrase[i];
+      if( pPhrase->nTerm>1 || pPhrase->aTerm[0].pSynonym || pNear->pColset ){
+        int bMatch = 0;
+        rc = fts5ExprPhraseIsMatch(pNode, pPhrase, &bMatch);
+        if( bMatch==0 ) break;
+      }else{
+        Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
+        fts5BufferSet(&rc, &pPhrase->poslist, pIter->nData, pIter->pData);
+      }
+    }
 
-  return rc;
+    *pRc = rc;
+    if( i==pNear->nPhrase && (i==1 || fts5ExprNearIsMatch(pRc, pNear)) ){
+      return 1;
+    }
+    return 0;
+  }
 }
 
+
 /*
 ** Initialize all term iterators in the pNear object. If any term is found
 ** to match no documents at all, return immediately without initializing any
@@ -172244,6 +173132,7 @@ static int fts5ExprNearInitAll(
   int i, j;
   int rc = SQLITE_OK;
 
+  assert( pNode->bNomatch==0 );
   for(i=0; rc==SQLITE_OK && i<pNear->nPhrase; i++){
     Fts5ExprPhrase *pPhrase = pNear->apPhrase[i];
     for(j=0; j<pPhrase->nTerm; j++){
@@ -172279,10 +173168,6 @@ static int fts5ExprNearInitAll(
   return rc;
 }
 
-/* fts5ExprNodeNext() calls fts5ExprNodeNextMatch(). And vice-versa. */
-static int fts5ExprNodeNextMatch(Fts5Expr*, Fts5ExprNode*);
-
-
 /*
 ** If pExpr is an ASC iterator, this function returns a value with the
 ** same sign as:
@@ -172311,6 +173196,7 @@ static int fts5RowidCmp(
 static void fts5ExprSetEof(Fts5ExprNode *pNode){
   int i;
   pNode->bEof = 1;
+  pNode->bNomatch = 0;
   for(i=0; i<pNode->nChild; i++){
     fts5ExprSetEof(pNode->apChild[i]);
   }
@@ -172333,12 +173219,275 @@ static void fts5ExprNodeZeroPoslist(Fts5ExprNode *pNode){
 }
 
 
-static int fts5ExprNodeNext(Fts5Expr*, Fts5ExprNode*, int, i64);
+
+/*
+** Compare the values currently indicated by the two nodes as follows:
+**
+**    res = (*p1) - (*p2)
+**
+** Nodes that point to values that come later in the iteration order are
+** considered to be larger. Nodes at EOF are the largest of all.
+**
+** This means that if the iteration order is ASC, then numerically larger
+** rowids are considered larger. Or if it is the default DESC, numerically
+** smaller rowids are larger.
+*/
+static int fts5NodeCompare(
+  Fts5Expr *pExpr,
+  Fts5ExprNode *p1, 
+  Fts5ExprNode *p2
+){
+  if( p2->bEof ) return -1;
+  if( p1->bEof ) return +1;
+  return fts5RowidCmp(pExpr, p1->iRowid, p2->iRowid);
+}
+
+/*
+** All individual term iterators in pNear are guaranteed to be valid when
+** this function is called. This function checks if all term iterators
+** point to the same rowid, and if not, advances them until they do.
+** If an EOF is reached before this happens, *pbEof is set to true before
+** returning.
+**
+** SQLITE_OK is returned if an error occurs, or an SQLite error code 
+** otherwise. It is not considered an error code if an iterator reaches
+** EOF.
+*/
+static int fts5ExprNodeTest_STRING(
+  Fts5Expr *pExpr,                /* Expression pPhrase belongs to */
+  Fts5ExprNode *pNode
+){
+  Fts5ExprNearset *pNear = pNode->pNear;
+  Fts5ExprPhrase *pLeft = pNear->apPhrase[0];
+  int rc = SQLITE_OK;
+  i64 iLast;                      /* Lastest rowid any iterator points to */
+  int i, j;                       /* Phrase and token index, respectively */
+  int bMatch;                     /* True if all terms are at the same rowid */
+  const int bDesc = pExpr->bDesc;
+
+  /* Check that this node should not be FTS5_TERM */
+  assert( pNear->nPhrase>1 
+       || pNear->apPhrase[0]->nTerm>1 
+       || pNear->apPhrase[0]->aTerm[0].pSynonym
+  );
+
+  /* Initialize iLast, the "lastest" rowid any iterator points to. If the
+  ** iterator skips through rowids in the default ascending order, this means
+  ** the maximum rowid. Or, if the iterator is "ORDER BY rowid DESC", then it
+  ** means the minimum rowid.  */
+  if( pLeft->aTerm[0].pSynonym ){
+    iLast = fts5ExprSynonymRowid(&pLeft->aTerm[0], bDesc, 0);
+  }else{
+    iLast = pLeft->aTerm[0].pIter->iRowid;
+  }
+
+  do {
+    bMatch = 1;
+    for(i=0; i<pNear->nPhrase; i++){
+      Fts5ExprPhrase *pPhrase = pNear->apPhrase[i];
+      for(j=0; j<pPhrase->nTerm; j++){
+        Fts5ExprTerm *pTerm = &pPhrase->aTerm[j];
+        if( pTerm->pSynonym ){
+          i64 iRowid = fts5ExprSynonymRowid(pTerm, bDesc, 0);
+          if( iRowid==iLast ) continue;
+          bMatch = 0;
+          if( fts5ExprSynonymAdvanceto(pTerm, bDesc, &iLast, &rc) ){
+            pNode->bNomatch = 0;
+            pNode->bEof = 1;
+            return rc;
+          }
+        }else{
+          Fts5IndexIter *pIter = pPhrase->aTerm[j].pIter;
+          if( pIter->iRowid==iLast ) continue;
+          bMatch = 0;
+          if( fts5ExprAdvanceto(pIter, bDesc, &iLast, &rc, &pNode->bEof) ){
+            return rc;
+          }
+        }
+      }
+    }
+  }while( bMatch==0 );
+
+  pNode->iRowid = iLast;
+  pNode->bNomatch = ((0==fts5ExprNearTest(&rc, pExpr, pNode)) && rc==SQLITE_OK);
+  assert( pNode->bEof==0 || pNode->bNomatch==0 );
+
+  return rc;
+}
+
+/*
+** Advance the first term iterator in the first phrase of pNear. Set output
+** variable *pbEof to true if it reaches EOF or if an error occurs.
+**
+** Return SQLITE_OK if successful, or an SQLite error code if an error
+** occurs.
+*/
+static int fts5ExprNodeNext_STRING(
+  Fts5Expr *pExpr,                /* Expression pPhrase belongs to */
+  Fts5ExprNode *pNode,            /* FTS5_STRING or FTS5_TERM node */
+  int bFromValid,
+  i64 iFrom 
+){
+  Fts5ExprTerm *pTerm = &pNode->pNear->apPhrase[0]->aTerm[0];
+  int rc = SQLITE_OK;
+
+  pNode->bNomatch = 0;
+  if( pTerm->pSynonym ){
+    int bEof = 1;
+    Fts5ExprTerm *p;
+
+    /* Find the firstest rowid any synonym points to. */
+    i64 iRowid = fts5ExprSynonymRowid(pTerm, pExpr->bDesc, 0);
+
+    /* Advance each iterator that currently points to iRowid. Or, if iFrom
+    ** is valid - each iterator that points to a rowid before iFrom.  */
+    for(p=pTerm; p; p=p->pSynonym){
+      if( sqlite3Fts5IterEof(p->pIter)==0 ){
+        i64 ii = p->pIter->iRowid;
+        if( ii==iRowid 
+         || (bFromValid && ii!=iFrom && (ii>iFrom)==pExpr->bDesc) 
+        ){
+          if( bFromValid ){
+            rc = sqlite3Fts5IterNextFrom(p->pIter, iFrom);
+          }else{
+            rc = sqlite3Fts5IterNext(p->pIter);
+          }
+          if( rc!=SQLITE_OK ) break;
+          if( sqlite3Fts5IterEof(p->pIter)==0 ){
+            bEof = 0;
+          }
+        }else{
+          bEof = 0;
+        }
+      }
+    }
+
+    /* Set the EOF flag if either all synonym iterators are at EOF or an
+    ** error has occurred.  */
+    pNode->bEof = (rc || bEof);
+  }else{
+    Fts5IndexIter *pIter = pTerm->pIter;
+
+    assert( Fts5NodeIsString(pNode) );
+    if( bFromValid ){
+      rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
+    }else{
+      rc = sqlite3Fts5IterNext(pIter);
+    }
+
+    pNode->bEof = (rc || sqlite3Fts5IterEof(pIter));
+  }
+
+  if( pNode->bEof==0 ){
+    assert( rc==SQLITE_OK );
+    rc = fts5ExprNodeTest_STRING(pExpr, pNode);
+  }
+
+  return rc;
+}
+
+
+static int fts5ExprNodeTest_TERM(
+  Fts5Expr *pExpr,                /* Expression that pNear is a part of */
+  Fts5ExprNode *pNode             /* The "NEAR" node (FTS5_TERM) */
+){
+  /* As this "NEAR" object is actually a single phrase that consists 
+  ** of a single term only, grab pointers into the poslist managed by the
+  ** fts5_index.c iterator object. This is much faster than synthesizing 
+  ** a new poslist the way we have to for more complicated phrase or NEAR
+  ** expressions.  */
+  Fts5ExprPhrase *pPhrase = pNode->pNear->apPhrase[0];
+  Fts5IndexIter *pIter = pPhrase->aTerm[0].pIter;
+
+  assert( pNode->eType==FTS5_TERM );
+  assert( pNode->pNear->nPhrase==1 && pPhrase->nTerm==1 );
+  assert( pPhrase->aTerm[0].pSynonym==0 );
+
+  pPhrase->poslist.n = pIter->nData;
+  if( pExpr->pConfig->eDetail==FTS5_DETAIL_FULL ){
+    pPhrase->poslist.p = (u8*)pIter->pData;
+  }
+  pNode->iRowid = pIter->iRowid;
+  pNode->bNomatch = (pPhrase->poslist.n==0);
+  return SQLITE_OK;
+}
+
+/*
+** xNext() method for a node of type FTS5_TERM.
+*/
+static int fts5ExprNodeNext_TERM(
+  Fts5Expr *pExpr, 
+  Fts5ExprNode *pNode,
+  int bFromValid,
+  i64 iFrom
+){
+  int rc;
+  Fts5IndexIter *pIter = pNode->pNear->apPhrase[0]->aTerm[0].pIter;
+
+  assert( pNode->bEof==0 );
+  if( bFromValid ){
+    rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
+  }else{
+    rc = sqlite3Fts5IterNext(pIter);
+  }
+  if( rc==SQLITE_OK && sqlite3Fts5IterEof(pIter)==0 ){
+    rc = fts5ExprNodeTest_TERM(pExpr, pNode);
+  }else{
+    pNode->bEof = 1;
+    pNode->bNomatch = 0;
+  }
+  return rc;
+}
+
+static void fts5ExprNodeTest_OR(
+  Fts5Expr *pExpr,                /* Expression of which pNode is a part */
+  Fts5ExprNode *pNode             /* Expression node to test */
+){
+  Fts5ExprNode *pNext = pNode->apChild[0];
+  int i;
+
+  for(i=1; i<pNode->nChild; i++){
+    Fts5ExprNode *pChild = pNode->apChild[i];
+    int cmp = fts5NodeCompare(pExpr, pNext, pChild);
+    if( cmp>0 || (cmp==0 && pChild->bNomatch==0) ){
+      pNext = pChild;
+    }
+  }
+  pNode->iRowid = pNext->iRowid;
+  pNode->bEof = pNext->bEof;
+  pNode->bNomatch = pNext->bNomatch;
+}
+
+static int fts5ExprNodeNext_OR(
+  Fts5Expr *pExpr, 
+  Fts5ExprNode *pNode,
+  int bFromValid,
+  i64 iFrom
+){
+  int i;
+  i64 iLast = pNode->iRowid;
+
+  for(i=0; i<pNode->nChild; i++){
+    Fts5ExprNode *p1 = pNode->apChild[i];
+    assert( p1->bEof || fts5RowidCmp(pExpr, p1->iRowid, iLast)>=0 );
+    if( p1->bEof==0 ){
+      if( (p1->iRowid==iLast) 
+       || (bFromValid && fts5RowidCmp(pExpr, p1->iRowid, iFrom)<0)
+      ){
+        int rc = fts5ExprNodeNext(pExpr, p1, bFromValid, iFrom);
+        if( rc!=SQLITE_OK ) return rc;
+      }
+    }
+  }
+
+  fts5ExprNodeTest_OR(pExpr, pNode);
+  return SQLITE_OK;
+}
 
 /*
 ** Argument pNode is an FTS5_AND node.
 */
-static int fts5ExprAndNextRowid(
+static int fts5ExprNodeTest_AND(
   Fts5Expr *pExpr,                /* Expression pPhrase belongs to */
   Fts5ExprNode *pAnd              /* FTS5_AND node to advance */
 ){
@@ -172353,15 +173502,11 @@ static int fts5ExprAndNextRowid(
     bMatch = 1;
     for(iChild=0; iChild<pAnd->nChild; iChild++){
       Fts5ExprNode *pChild = pAnd->apChild[iChild];
-      if( 0 && pChild->eType==FTS5_STRING ){
-        /* TODO */
-      }else{
-        int cmp = fts5RowidCmp(pExpr, iLast, pChild->iRowid);
-        if( cmp>0 ){
-          /* Advance pChild until it points to iLast or laster */
-          rc = fts5ExprNodeNext(pExpr, pChild, 1, iLast);
-          if( rc!=SQLITE_OK ) return rc;
-        }
+      int cmp = fts5RowidCmp(pExpr, iLast, pChild->iRowid);
+      if( cmp>0 ){
+        /* Advance pChild until it points to iLast or laster */
+        rc = fts5ExprNodeNext(pExpr, pChild, 1, iLast);
+        if( rc!=SQLITE_OK ) return rc;
       }
 
       /* If the child node is now at EOF, so is the parent AND node. Otherwise,
@@ -172391,126 +173536,66 @@ static int fts5ExprAndNextRowid(
   return SQLITE_OK;
 }
 
-
-/*
-** Compare the values currently indicated by the two nodes as follows:
-**
-**    res = (*p1) - (*p2)
-**
-** Nodes that point to values that come later in the iteration order are
-** considered to be larger. Nodes at EOF are the largest of all.
-**
-** This means that if the iteration order is ASC, then numerically larger
-** rowids are considered larger. Or if it is the default DESC, numerically
-** smaller rowids are larger.
-*/
-static int fts5NodeCompare(
-  Fts5Expr *pExpr,
-  Fts5ExprNode *p1, 
-  Fts5ExprNode *p2
-){
-  if( p2->bEof ) return -1;
-  if( p1->bEof ) return +1;
-  return fts5RowidCmp(pExpr, p1->iRowid, p2->iRowid);
-}
-
-/*
-** Advance node iterator pNode, part of expression pExpr. If argument
-** bFromValid is zero, then pNode is advanced exactly once. Or, if argument
-** bFromValid is non-zero, then pNode is advanced until it is at or past
-** rowid value iFrom. Whether "past" means "less than" or "greater than"
-** depends on whether this is an ASC or DESC iterator.
-*/
-static int fts5ExprNodeNext(
+static int fts5ExprNodeNext_AND(
   Fts5Expr *pExpr, 
   Fts5ExprNode *pNode,
   int bFromValid,
   i64 iFrom
 ){
-  int rc = SQLITE_OK;
-
-  if( pNode->bEof==0 ){
-    switch( pNode->eType ){
-      case FTS5_STRING: {
-        rc = fts5ExprNearAdvanceFirst(pExpr, pNode, bFromValid, iFrom);
-        break;
-      };
-
-      case FTS5_TERM: {
-        Fts5IndexIter *pIter = pNode->pNear->apPhrase[0]->aTerm[0].pIter;
-        if( bFromValid ){
-          rc = sqlite3Fts5IterNextFrom(pIter, iFrom);
-        }else{
-          rc = sqlite3Fts5IterNext(pIter);
-        }
-        if( rc==SQLITE_OK && sqlite3Fts5IterEof(pIter)==0 ){
-          assert( rc==SQLITE_OK );
-          rc = fts5ExprTokenTest(pExpr, pNode);
-        }else{
-          pNode->bEof = 1;
-        }
-        return rc;
-      };
-
-      case FTS5_AND: {
-        Fts5ExprNode *pLeft = pNode->apChild[0];
-        rc = fts5ExprNodeNext(pExpr, pLeft, bFromValid, iFrom);
-        break;
-      }
-
-      case FTS5_OR: {
-        int i;
-        i64 iLast = pNode->iRowid;
-
-        for(i=0; rc==SQLITE_OK && i<pNode->nChild; i++){
-          Fts5ExprNode *p1 = pNode->apChild[i];
-          assert( p1->bEof || fts5RowidCmp(pExpr, p1->iRowid, iLast)>=0 );
-          if( p1->bEof==0 ){
-            if( (p1->iRowid==iLast) 
-             || (bFromValid && fts5RowidCmp(pExpr, p1->iRowid, iFrom)<0)
-            ){
-              rc = fts5ExprNodeNext(pExpr, p1, bFromValid, iFrom);
-            }
-          }
-        }
-
-        break;
-      }
-
-      default: assert( pNode->eType==FTS5_NOT ); {
-        assert( pNode->nChild==2 );
-        rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
-        break;
-      }
-    }
-
-    if( rc==SQLITE_OK ){
-      rc = fts5ExprNodeNextMatch(pExpr, pNode);
-    }
+  int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
+  if( rc==SQLITE_OK ){
+    rc = fts5ExprNodeTest_AND(pExpr, pNode);
   }
-
-  /* Assert that if bFromValid was true, either:
-  **
-  **   a) an error occurred, or
-  **   b) the node is now at EOF, or
-  **   c) the node is now at or past rowid iFrom.
-  */
-  assert( bFromValid==0 
-      || rc!=SQLITE_OK                                                  /* a */
-      || pNode->bEof                                                    /* b */
-      || pNode->iRowid==iFrom || pExpr->bDesc==(pNode->iRowid<iFrom)    /* c */
-  );
-
   return rc;
 }
 
+static int fts5ExprNodeTest_NOT(
+  Fts5Expr *pExpr,                /* Expression pPhrase belongs to */
+  Fts5ExprNode *pNode             /* FTS5_NOT node to advance */
+){
+  int rc = SQLITE_OK;
+  Fts5ExprNode *p1 = pNode->apChild[0];
+  Fts5ExprNode *p2 = pNode->apChild[1];
+  assert( pNode->nChild==2 );
+
+  while( rc==SQLITE_OK && p1->bEof==0 ){
+    int cmp = fts5NodeCompare(pExpr, p1, p2);
+    if( cmp>0 ){
+      rc = fts5ExprNodeNext(pExpr, p2, 1, p1->iRowid);
+      cmp = fts5NodeCompare(pExpr, p1, p2);
+    }
+    assert( rc!=SQLITE_OK || cmp<=0 );
+    if( cmp || p2->bNomatch ) break;
+    rc = fts5ExprNodeNext(pExpr, p1, 0, 0);
+  }
+  pNode->bEof = p1->bEof;
+  pNode->bNomatch = p1->bNomatch;
+  pNode->iRowid = p1->iRowid;
+  if( p1->bEof ){
+    fts5ExprNodeZeroPoslist(p2);
+  }
+  return rc;
+}
+
+static int fts5ExprNodeNext_NOT(
+  Fts5Expr *pExpr, 
+  Fts5ExprNode *pNode,
+  int bFromValid,
+  i64 iFrom
+){
+  int rc = fts5ExprNodeNext(pExpr, pNode->apChild[0], bFromValid, iFrom);
+  if( rc==SQLITE_OK ){
+    rc = fts5ExprNodeTest_NOT(pExpr, pNode);
+  }
+  return rc;
+}
 
 /*
 ** If pNode currently points to a match, this function returns SQLITE_OK
 ** without modifying it. Otherwise, pNode is advanced until it does point
 ** to a match or EOF is reached.
 */
-static int fts5ExprNodeNextMatch(
+static int fts5ExprNodeTest(
   Fts5Expr *pExpr,                /* Expression of which pNode is a part */
   Fts5ExprNode *pNode             /* Expression node to test */
 ){
@@ -172519,55 +173604,27 @@ static int fts5ExprNodeNextMatch(
     switch( pNode->eType ){
 
       case FTS5_STRING: {
-        /* Advance the iterators until they all point to the same rowid */
-        rc = fts5ExprNearNextMatch(pExpr, pNode);
+        rc = fts5ExprNodeTest_STRING(pExpr, pNode);
         break;
       }
 
       case FTS5_TERM: {
-        rc = fts5ExprTokenTest(pExpr, pNode);
+        rc = fts5ExprNodeTest_TERM(pExpr, pNode);
         break;
       }
 
       case FTS5_AND: {
-        rc = fts5ExprAndNextRowid(pExpr, pNode);
+        rc = fts5ExprNodeTest_AND(pExpr, pNode);
         break;
       }
 
       case FTS5_OR: {
-        Fts5ExprNode *pNext = pNode->apChild[0];
-        int i;
-
-        for(i=1; i<pNode->nChild; i++){
-          Fts5ExprNode *pChild = pNode->apChild[i];
-          int cmp = fts5NodeCompare(pExpr, pNext, pChild);
-          if( cmp>0 || (cmp==0 && pChild->bNomatch==0) ){
-            pNext = pChild;
-          }
-        }
-        pNode->iRowid = pNext->iRowid;
-        pNode->bEof = pNext->bEof;
-        pNode->bNomatch = pNext->bNomatch;
+        fts5ExprNodeTest_OR(pExpr, pNode);
         break;
       }
 
       default: assert( pNode->eType==FTS5_NOT ); {
-        Fts5ExprNode *p1 = pNode->apChild[0];
-        Fts5ExprNode *p2 = pNode->apChild[1];
-        assert( pNode->nChild==2 );
-
-        while( rc==SQLITE_OK && p1->bEof==0 ){
-          int cmp = fts5NodeCompare(pExpr, p1, p2);
-          if( cmp>0 ){
-            rc = fts5ExprNodeNext(pExpr, p2, 1, p1->iRowid);
-            cmp = fts5NodeCompare(pExpr, p1, p2);
-          }
-          assert( rc!=SQLITE_OK || cmp<=0 );
-          if( cmp || p2->bNomatch ) break;
-          rc = fts5ExprNodeNext(pExpr, p1, 0, 0);
-        }
-        pNode->bEof = p1->bEof;
-        pNode->iRowid = p1->iRowid;
+        rc = fts5ExprNodeTest_NOT(pExpr, pNode);
         break;
       }
     }
@@ -172586,20 +173643,40 @@ static int fts5ExprNodeNextMatch(
 static int fts5ExprNodeFirst(Fts5Expr *pExpr, Fts5ExprNode *pNode){
   int rc = SQLITE_OK;
   pNode->bEof = 0;
+  pNode->bNomatch = 0;
 
   if( Fts5NodeIsString(pNode) ){
     /* Initialize all term iterators in the NEAR object. */
     rc = fts5ExprNearInitAll(pExpr, pNode);
   }else{
     int i;
+    int nEof = 0;
     for(i=0; i<pNode->nChild && rc==SQLITE_OK; i++){
+      Fts5ExprNode *pChild = pNode->apChild[i];
       rc = fts5ExprNodeFirst(pExpr, pNode->apChild[i]);
+      assert( pChild->bEof==0 || pChild->bEof==1 );
+      nEof += pChild->bEof;
     }
     pNode->iRowid = pNode->apChild[0]->iRowid;
+
+    switch( pNode->eType ){
+      case FTS5_AND:
+        if( nEof>0 ) fts5ExprSetEof(pNode);
+        break;
+
+      case FTS5_OR:
+        if( pNode->nChild==nEof ) fts5ExprSetEof(pNode);
+        break;
+
+      default:
+        assert( pNode->eType==FTS5_NOT );
+        pNode->bEof = pNode->apChild[0]->bEof;
+        break;
+    }
   }
 
   if( rc==SQLITE_OK ){
-    rc = fts5ExprNodeNextMatch(pExpr, pNode);
+    rc = fts5ExprNodeTest(pExpr, pNode);
   }
   return rc;
 }
@@ -172623,7 +173700,7 @@ static int fts5ExprNodeFirst(Fts5Expr *pExpr, Fts5ExprNode *pNode){
 static int sqlite3Fts5ExprFirst(Fts5Expr *p, Fts5Index *pIdx, i64 iFirst, int bDesc){
   Fts5ExprNode *pRoot = p->pRoot;
   int rc = SQLITE_OK;
-  if( pRoot ){
+  if( pRoot->xNext ){
     p->pIndex = pIdx;
     p->bDesc = bDesc;
     rc = fts5ExprNodeFirst(p, pRoot);
@@ -172635,7 +173712,8 @@ static int sqlite3Fts5ExprFirst(Fts5Expr *p, Fts5Index *pIdx, i64 iFirst, int bD
     }
 
     /* If the iterator is not at a real match, skip forward until it is. */
-    while( pRoot->bNomatch && rc==SQLITE_OK && pRoot->bEof==0 ){
+    while( pRoot->bNomatch ){
+      assert( pRoot->bEof==0 && rc==SQLITE_OK );
       rc = fts5ExprNodeNext(p, pRoot, 0, 0);
     }
   }
@@ -172651,9 +173729,11 @@ static int sqlite3Fts5ExprFirst(Fts5Expr *p, Fts5Index *pIdx, i64 iFirst, int bD
 static int sqlite3Fts5ExprNext(Fts5Expr *p, i64 iLast){
   int rc;
   Fts5ExprNode *pRoot = p->pRoot;
+  assert( pRoot->bEof==0 && pRoot->bNomatch==0 );
   do {
     rc = fts5ExprNodeNext(p, pRoot, 0, 0);
-  }while( pRoot->bNomatch && pRoot->bEof==0 && rc==SQLITE_OK );
+    assert( pRoot->bNomatch==0 || (rc==SQLITE_OK && pRoot->bEof==0) );
+  }while( pRoot->bNomatch );
   if( fts5RowidCmp(p, pRoot->iRowid, iLast)>0 ){
     pRoot->bEof = 1;
   }
@@ -172661,7 +173741,7 @@ static int sqlite3Fts5ExprNext(Fts5Expr *p, i64 iLast){
 }
 
 static int sqlite3Fts5ExprEof(Fts5Expr *p){
-  return (p->pRoot==0 || p->pRoot->bEof);
+  return p->pRoot->bEof;
 }
 
 static i64 sqlite3Fts5ExprRowid(Fts5Expr *p){
@@ -172686,10 +173766,10 @@ static void fts5ExprPhraseFree(Fts5ExprPhrase *pPhrase){
       Fts5ExprTerm *pTerm = &pPhrase->aTerm[i];
       sqlite3_free(pTerm->zTerm);
       sqlite3Fts5IterClose(pTerm->pIter);
-
       for(pSyn=pTerm->pSynonym; pSyn; pSyn=pNext){
         pNext = pSyn->pSynonym;
         sqlite3Fts5IterClose(pSyn->pIter);
+        fts5BufferFree((Fts5Buffer*)&pSyn[1]);
         sqlite3_free(pSyn);
       }
     }
@@ -172771,19 +173851,21 @@ static int fts5ParseTokenize(
   TokenCtx *pCtx = (TokenCtx*)pContext;
   Fts5ExprPhrase *pPhrase = pCtx->pPhrase;
 
+  UNUSED_PARAM2(iUnused1, iUnused2);
+
   /* If an error has already occurred, this is a no-op */
   if( pCtx->rc!=SQLITE_OK ) return pCtx->rc;
 
   assert( pPhrase==0 || pPhrase->nTerm>0 );
   if( pPhrase && (tflags & FTS5_TOKEN_COLOCATED) ){
     Fts5ExprTerm *pSyn;
-    int nByte = sizeof(Fts5ExprTerm) + nToken+1;
+    int nByte = sizeof(Fts5ExprTerm) + sizeof(Fts5Buffer) + nToken+1;
     pSyn = (Fts5ExprTerm*)sqlite3_malloc(nByte);
     if( pSyn==0 ){
       rc = SQLITE_NOMEM;
     }else{
       memset(pSyn, 0, nByte);
-      pSyn->zTerm = (char*)&pSyn[1];
+      pSyn->zTerm = ((char*)pSyn) + sizeof(Fts5ExprTerm) + sizeof(Fts5Buffer);
       memcpy(pSyn->zTerm, pToken, nToken);
       pSyn->pSynonym = pPhrase->aTerm[pPhrase->nTerm-1].pSynonym;
       pPhrase->aTerm[pPhrase->nTerm-1].pSynonym = pSyn;
@@ -172906,7 +173988,6 @@ static Fts5ExprPhrase *sqlite3Fts5ParseTerm(
 ** expression passed as the second argument.
 */
 static int sqlite3Fts5ExprClonePhrase(
-  Fts5Config *pConfig,
   Fts5Expr *pExpr, 
   int iPhrase, 
   Fts5Expr **ppNew
@@ -172914,14 +173995,10 @@ static int sqlite3Fts5ExprClonePhrase(
   int rc = SQLITE_OK;             /* Return code */
   Fts5ExprPhrase *pOrig;          /* The phrase extracted from pExpr */
   int i;                          /* Used to iterate through phrase terms */
-
   Fts5Expr *pNew = 0;             /* Expression to return via *ppNew */
-
   TokenCtx sCtx = {0,0};          /* Context object for fts5ParseTokenize */
 
-
   pOrig = pExpr->apExprPhrase[iPhrase];
-
   pNew = (Fts5Expr*)sqlite3Fts5MallocZero(&rc, sizeof(Fts5Expr));
   if( rc==SQLITE_OK ){
     pNew->apExprPhrase = (Fts5ExprPhrase**)sqlite3Fts5MallocZero(&rc, 
@@ -172953,6 +174030,7 @@ static int sqlite3Fts5ExprClonePhrase(
   if( rc==SQLITE_OK ){
     /* All the allocations succeeded. Put the expression object together. */
     pNew->pIndex = pExpr->pIndex;
+    pNew->pConfig = pExpr->pConfig;
     pNew->nPhrase = 1;
     pNew->apExprPhrase[0] = sCtx.pPhrase;
     pNew->pRoot->pNear->apPhrase[0] = sCtx.pPhrase;
@@ -172961,8 +174039,10 @@ static int sqlite3Fts5ExprClonePhrase(
 
     if( pOrig->nTerm==1 && pOrig->aTerm[0].pSynonym==0 ){
       pNew->pRoot->eType = FTS5_TERM;
+      pNew->pRoot->xNext = fts5ExprNodeNext_TERM;
     }else{
       pNew->pRoot->eType = FTS5_STRING;
+      pNew->pRoot->xNext = fts5ExprNodeNext_STRING;
     }
   }else{
     sqlite3Fts5ExprFree(pNew);
@@ -173094,6 +174174,15 @@ static void sqlite3Fts5ParseSetColset(
   Fts5ExprNearset *pNear, 
   Fts5Colset *pColset 
 ){
+  if( pParse->pConfig->eDetail==FTS5_DETAIL_NONE ){
+    pParse->rc = SQLITE_ERROR;
+    pParse->zErr = sqlite3_mprintf(
+      "fts5: column queries are not supported (detail=none)"
+    );
+    sqlite3_free(pColset);
+    return;
+  }
+
   if( pNear ){
     pNear->pColset = pColset;
   }else{
@@ -173101,6 +174190,38 @@ static void sqlite3Fts5ParseSetColset(
   }
 }
 
+static void fts5ExprAssignXNext(Fts5ExprNode *pNode){
+  switch( pNode->eType ){
+    case FTS5_STRING: {
+      Fts5ExprNearset *pNear = pNode->pNear;
+      if( pNear->nPhrase==1 && pNear->apPhrase[0]->nTerm==1 
+       && pNear->apPhrase[0]->aTerm[0].pSynonym==0
+      ){
+        pNode->eType = FTS5_TERM;
+        pNode->xNext = fts5ExprNodeNext_TERM;
+      }else{
+        pNode->xNext = fts5ExprNodeNext_STRING;
+      }
+      break;
+    };
+
+    case FTS5_OR: {
+      pNode->xNext = fts5ExprNodeNext_OR;
+      break;
+    };
+
+    case FTS5_AND: {
+      pNode->xNext = fts5ExprNodeNext_AND;
+      break;
+    };
+
+    default: assert( pNode->eType==FTS5_NOT ); {
+      pNode->xNext = fts5ExprNodeNext_NOT;
+      break;
+    };
+  }
+}
+
 static void fts5ExprAddChildren(Fts5ExprNode *p, Fts5ExprNode *pSub){
   if( p->eType!=FTS5_NOT && pSub->eType==p->eType ){
     int nByte = sizeof(Fts5ExprNode*) * pSub->nChild;
@@ -173150,17 +174271,27 @@ static Fts5ExprNode *sqlite3Fts5ParseNode(
     if( pRet ){
       pRet->eType = eType;
       pRet->pNear = pNear;
+      fts5ExprAssignXNext(pRet);
       if( eType==FTS5_STRING ){
         int iPhrase;
         for(iPhrase=0; iPhrase<pNear->nPhrase; iPhrase++){
           pNear->apPhrase[iPhrase]->pNode = pRet;
         }
-        if( pNear->nPhrase==1 
-         && pNear->apPhrase[0]->nTerm==1 
-         && pNear->apPhrase[0]->aTerm[0].pSynonym==0
+
+        if( pParse->pConfig->eDetail!=FTS5_DETAIL_FULL 
+         && (pNear->nPhrase!=1 || pNear->apPhrase[0]->nTerm!=1)
         ){
-          pRet->eType = FTS5_TERM;
+          assert( pParse->rc==SQLITE_OK );
+          pParse->rc = SQLITE_ERROR;
+          assert( pParse->zErr==0 );
+          pParse->zErr = sqlite3_mprintf(
+              "fts5: %s queries are not supported (detail!=full)", 
+              pNear->nPhrase==1 ? "phrase": "NEAR"
+          );
+          sqlite3_free(pRet);
+          pRet = 0;
         }
+
       }else{
         fts5ExprAddChildren(pRet, pLeft);
         fts5ExprAddChildren(pRet, pRight);
@@ -173273,6 +174404,9 @@ static char *fts5ExprPrintTcl(
       for(iTerm=0; zRet && iTerm<pPhrase->nTerm; iTerm++){
         char *zTerm = pPhrase->aTerm[iTerm].zTerm;
         zRet = fts5PrintfAppend(zRet, "%s%s", iTerm==0?"":" ", zTerm);
+        if( pPhrase->aTerm[iTerm].bPrefix ){
+          zRet = fts5PrintfAppend(zRet, "*");
+        }
       }
 
       if( zRet ) zRet = fts5PrintfAppend(zRet, "}");
@@ -173440,7 +174574,7 @@ static void fts5ExprFunction(
   }
   if( rc==SQLITE_OK ){
     char *zText;
-    if( pExpr->pRoot==0 ){
+    if( pExpr->pRoot->xNext==0 ){
       zText = sqlite3_mprintf("");
     }else if( bTcl ){
       zText = fts5ExprPrintTcl(pConfig, zNearsetCmd, pExpr->pRoot);
@@ -173540,7 +174674,7 @@ static int sqlite3Fts5ExprInit(Fts5Global *pGlobal, sqlite3 *db){
   int rc = SQLITE_OK;
   void *pCtx = (void*)pGlobal;
 
-  for(i=0; rc==SQLITE_OK && i<(int)ArraySize(aFunc); i++){
+  for(i=0; rc==SQLITE_OK && i<ArraySize(aFunc); i++){
     struct Fts5ExprFunc *p = &aFunc[i];
     rc = sqlite3_create_function(db, p->z, -1, SQLITE_UTF8, pCtx, p->x, 0, 0);
   }
@@ -173586,6 +174720,225 @@ static int sqlite3Fts5ExprPoslist(Fts5Expr *pExpr, int iPhrase, const u8 **pa){
   return nRet;
 }
 
+struct Fts5PoslistPopulator {
+  Fts5PoslistWriter writer;
+  int bOk;                        /* True if ok to populate */
+  int bMiss;
+};
+
+static Fts5PoslistPopulator *sqlite3Fts5ExprClearPoslists(Fts5Expr *pExpr, int bLive){
+  Fts5PoslistPopulator *pRet;
+  pRet = sqlite3_malloc(sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
+  if( pRet ){
+    int i;
+    memset(pRet, 0, sizeof(Fts5PoslistPopulator)*pExpr->nPhrase);
+    for(i=0; i<pExpr->nPhrase; i++){
+      Fts5Buffer *pBuf = &pExpr->apExprPhrase[i]->poslist;
+      Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
+      assert( pExpr->apExprPhrase[i]->nTerm==1 );
+      if( bLive && 
+          (pBuf->n==0 || pNode->iRowid!=pExpr->pRoot->iRowid || pNode->bEof)
+      ){
+        pRet[i].bMiss = 1;
+      }else{
+        pBuf->n = 0;
+      }
+    }
+  }
+  return pRet;
+}
+
+struct Fts5ExprCtx {
+  Fts5Expr *pExpr;
+  Fts5PoslistPopulator *aPopulator;
+  i64 iOff;
+};
+typedef struct Fts5ExprCtx Fts5ExprCtx;
+
+/*
+** TODO: Make this more efficient!
+*/
+static int fts5ExprColsetTest(Fts5Colset *pColset, int iCol){
+  int i;
+  for(i=0; i<pColset->nCol; i++){
+    if( pColset->aiCol[i]==iCol ) return 1;
+  }
+  return 0;
+}
+
+static int fts5ExprPopulatePoslistsCb(
+  void *pCtx,                /* Copy of 2nd argument to xTokenize() */
+  int tflags,                /* Mask of FTS5_TOKEN_* flags */
+  const char *pToken,        /* Pointer to buffer containing token */
+  int nToken,                /* Size of token in bytes */
+  int iUnused1,              /* Byte offset of token within input text */
+  int iUnused2               /* Byte offset of end of token within input text */
+){
+  Fts5ExprCtx *p = (Fts5ExprCtx*)pCtx;
+  Fts5Expr *pExpr = p->pExpr;
+  int i;
+
+  UNUSED_PARAM2(iUnused1, iUnused2);
+
+  if( (tflags & FTS5_TOKEN_COLOCATED)==0 ) p->iOff++;
+  for(i=0; i<pExpr->nPhrase; i++){
+    Fts5ExprTerm *pTerm;
+    if( p->aPopulator[i].bOk==0 ) continue;
+    for(pTerm=&pExpr->apExprPhrase[i]->aTerm[0]; pTerm; pTerm=pTerm->pSynonym){
+      int nTerm = strlen(pTerm->zTerm);
+      if( (nTerm==nToken || (nTerm<nToken && pTerm->bPrefix))
+       && memcmp(pTerm->zTerm, pToken, nTerm)==0
+      ){
+        int rc = sqlite3Fts5PoslistWriterAppend(
+            &pExpr->apExprPhrase[i]->poslist, &p->aPopulator[i].writer, p->iOff
+        );
+        if( rc ) return rc;
+        break;
+      }
+    }
+  }
+  return SQLITE_OK;
+}
+
+static int sqlite3Fts5ExprPopulatePoslists(
+  Fts5Config *pConfig,
+  Fts5Expr *pExpr, 
+  Fts5PoslistPopulator *aPopulator,
+  int iCol, 
+  const char *z, int n
+){
+  int i;
+  Fts5ExprCtx sCtx;
+  sCtx.pExpr = pExpr;
+  sCtx.aPopulator = aPopulator;
+  sCtx.iOff = (((i64)iCol) << 32) - 1;
+
+  for(i=0; i<pExpr->nPhrase; i++){
+    Fts5ExprNode *pNode = pExpr->apExprPhrase[i]->pNode;
+    Fts5Colset *pColset = pNode->pNear->pColset;
+    if( (pColset && 0==fts5ExprColsetTest(pColset, iCol)) 
+     || aPopulator[i].bMiss
+    ){
+      aPopulator[i].bOk = 0;
+    }else{
+      aPopulator[i].bOk = 1;
+    }
+  }
+
+  return sqlite3Fts5Tokenize(pConfig, 
+      FTS5_TOKENIZE_DOCUMENT, z, n, (void*)&sCtx, fts5ExprPopulatePoslistsCb
+  );
+}
+
+static void fts5ExprClearPoslists(Fts5ExprNode *pNode){
+  if( pNode->eType==FTS5_TERM || pNode->eType==FTS5_STRING ){
+    pNode->pNear->apPhrase[0]->poslist.n = 0;
+  }else{
+    int i;
+    for(i=0; i<pNode->nChild; i++){
+      fts5ExprClearPoslists(pNode->apChild[i]);
+    }
+  }
+}
+
+static int fts5ExprCheckPoslists(Fts5ExprNode *pNode, i64 iRowid){
+  pNode->iRowid = iRowid;
+  pNode->bEof = 0;
+  switch( pNode->eType ){
+    case FTS5_TERM:
+    case FTS5_STRING:
+      return (pNode->pNear->apPhrase[0]->poslist.n>0);
+
+    case FTS5_AND: {
+      int i;
+      for(i=0; i<pNode->nChild; i++){
+        if( fts5ExprCheckPoslists(pNode->apChild[i], iRowid)==0 ){
+          fts5ExprClearPoslists(pNode);
+          return 0;
+        }
+      }
+      break;
+    }
+
+    case FTS5_OR: {
+      int i;
+      int bRet = 0;
+      for(i=0; i<pNode->nChild; i++){
+        if( fts5ExprCheckPoslists(pNode->apChild[i], iRowid) ){
+          bRet = 1;
+        }
+      }
+      return bRet;
+    }
+
+    default: {
+      assert( pNode->eType==FTS5_NOT );
+      if( 0==fts5ExprCheckPoslists(pNode->apChild[0], iRowid)
+          || 0!=fts5ExprCheckPoslists(pNode->apChild[1], iRowid)
+        ){
+        fts5ExprClearPoslists(pNode);
+        return 0;
+      }
+      break;
+    }
+  }
+  return 1;
+}
+
+static void sqlite3Fts5ExprCheckPoslists(Fts5Expr *pExpr, i64 iRowid){
+  fts5ExprCheckPoslists(pExpr->pRoot, iRowid);
+}
+
+static void fts5ExprClearEof(Fts5ExprNode *pNode){
+  int i;
+  for(i=0; i<pNode->nChild; i++){
+    fts5ExprClearEof(pNode->apChild[i]);
+  }
+  pNode->bEof = 0;
+}
+static void sqlite3Fts5ExprClearEof(Fts5Expr *pExpr){
+  fts5ExprClearEof(pExpr->pRoot);
+}
+
+/*
+** This function is only called for detail=columns tables. 
+*/
+static int sqlite3Fts5ExprPhraseCollist(
+  Fts5Expr *pExpr, 
+  int iPhrase, 
+  const u8 **ppCollist, 
+  int *pnCollist
+){
+  Fts5ExprPhrase *pPhrase = pExpr->apExprPhrase[iPhrase];
+  Fts5ExprNode *pNode = pPhrase->pNode;
+  int rc = SQLITE_OK;
+
+  assert( iPhrase>=0 && iPhrase<pExpr->nPhrase );
+  assert( pExpr->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
+
+  if( pNode->bEof==0 
+   && pNode->iRowid==pExpr->pRoot->iRowid 
+   && pPhrase->poslist.n>0
+  ){
+    Fts5ExprTerm *pTerm = &pPhrase->aTerm[0];
+    if( pTerm->pSynonym ){
+      Fts5Buffer *pBuf = (Fts5Buffer*)&pTerm->pSynonym[1];
+      rc = fts5ExprSynonymList(
+          pTerm, pNode->iRowid, pBuf, (u8**)ppCollist, pnCollist
+      );
+    }else{
+      *ppCollist = pPhrase->aTerm[0].pIter->pData;
+      *pnCollist = pPhrase->aTerm[0].pIter->nData;
+    }
+  }else{
+    *ppCollist = 0;
+    *pnCollist = 0;
+  }
+
+  return rc;
+}
+
+
 /*
 ** 2014 August 11
 **
@@ -173614,6 +174967,7 @@ typedef struct Fts5HashEntry Fts5HashEntry;
 
 
 struct Fts5Hash {
+  int eDetail;                    /* Copy of Fts5Config.eDetail */
   int *pnByte;                    /* Pointer to bytes counter */
   int nEntry;                     /* Number of entries currently in hash */
   int nSlot;                      /* Size of aSlot[] array */
@@ -173649,9 +175003,10 @@ struct Fts5HashEntry {
   int nAlloc;                     /* Total size of allocation */
   int iSzPoslist;                 /* Offset of space for 4-byte poslist size */
   int nData;                      /* Total bytes of data (incl. structure) */
+  int nKey;                       /* Length of zKey[] in bytes */
   u8 bDel;                        /* Set delete-flag @ iSzPoslist */
-
-  int iCol;                       /* Column of last value written */
+  u8 bContent;                    /* Set content-flag (detail=none mode) */
+  i16 iCol;                       /* Column of last value written */
   int iPos;                       /* Position of last value written */
   i64 iRowid;                     /* Rowid of last value written */
   char zKey[8];                   /* Nul-terminated entry key */
@@ -173667,7 +175022,7 @@ struct Fts5HashEntry {
 /*
 ** Allocate a new hash table.
 */
-static int sqlite3Fts5HashNew(Fts5Hash **ppNew, int *pnByte){
+static int sqlite3Fts5HashNew(Fts5Config *pConfig, Fts5Hash **ppNew, int *pnByte){
   int rc = SQLITE_OK;
   Fts5Hash *pNew;
 
@@ -173678,6 +175033,7 @@ static int sqlite3Fts5HashNew(Fts5Hash **ppNew, int *pnByte){
     int nByte;
     memset(pNew, 0, sizeof(Fts5Hash));
     pNew->pnByte = pnByte;
+    pNew->eDetail = pConfig->eDetail;
 
     pNew->nSlot = 1024;
     nByte = sizeof(Fts5HashEntry*) * pNew->nSlot;
@@ -173770,26 +175126,46 @@ static int fts5HashResize(Fts5Hash *pHash){
   return SQLITE_OK;
 }
 
-static void fts5HashAddPoslistSize(Fts5HashEntry *p){
+static void fts5HashAddPoslistSize(Fts5Hash *pHash, Fts5HashEntry *p){
   if( p->iSzPoslist ){
     u8 *pPtr = (u8*)p;
-    int nSz = (p->nData - p->iSzPoslist - 1);         /* Size in bytes */
-    int nPos = nSz*2 + p->bDel;                       /* Value of nPos field */
-
-    assert( p->bDel==0 || p->bDel==1 );
-    if( nPos<=127 ){
-      pPtr[p->iSzPoslist] = (u8)nPos;
+    if( pHash->eDetail==FTS5_DETAIL_NONE ){
+      assert( p->nData==p->iSzPoslist );
+      if( p->bDel ){
+        pPtr[p->nData++] = 0x00;
+        if( p->bContent ){
+          pPtr[p->nData++] = 0x00;
+        }
+      }
     }else{
-      int nByte = sqlite3Fts5GetVarintLen((u32)nPos);
-      memmove(&pPtr[p->iSzPoslist + nByte], &pPtr[p->iSzPoslist + 1], nSz);
-      sqlite3Fts5PutVarint(&pPtr[p->iSzPoslist], nPos);
-      p->nData += (nByte-1);
+      int nSz = (p->nData - p->iSzPoslist - 1);       /* Size in bytes */
+      int nPos = nSz*2 + p->bDel;                     /* Value of nPos field */
+
+      assert( p->bDel==0 || p->bDel==1 );
+      if( nPos<=127 ){
+        pPtr[p->iSzPoslist] = (u8)nPos;
+      }else{
+        int nByte = sqlite3Fts5GetVarintLen((u32)nPos);
+        memmove(&pPtr[p->iSzPoslist + nByte], &pPtr[p->iSzPoslist + 1], nSz);
+        sqlite3Fts5PutVarint(&pPtr[p->iSzPoslist], nPos);
+        p->nData += (nByte-1);
+      }
     }
-    p->bDel = 0;
+
     p->iSzPoslist = 0;
+    p->bDel = 0;
+    p->bContent = 0;
   }
 }
 
+/*
+** Add an entry to the in-memory hash table. The key is the concatenation
+** of bByte and (pToken/nToken). The value is (iRowid/iCol/iPos).
+**
+**     (bByte || pToken) -> (iRowid,iCol,iPos)
+**
+** Or, if iCol is negative, then the value is a delete marker.
+*/
 static int sqlite3Fts5HashWrite(
   Fts5Hash *pHash,
   i64 iRowid,                     /* Rowid for this entry */
@@ -173802,13 +175178,16 @@ static int sqlite3Fts5HashWrite(
   Fts5HashEntry *p;
   u8 *pPtr;
   int nIncr = 0;                  /* Amount to increment (*pHash->pnByte) by */
+  int bNew;                       /* If non-delete entry should be written */
+  
+  bNew = (pHash->eDetail==FTS5_DETAIL_FULL);
 
   /* Attempt to locate an existing hash entry */
   iHash = fts5HashKey2(pHash->nSlot, (u8)bByte, (const u8*)pToken, nToken);
   for(p=pHash->aSlot[iHash]; p; p=p->pHashNext){
     if( p->zKey[0]==bByte 
+     && p->nKey==nToken
      && memcmp(&p->zKey[1], pToken, nToken)==0 
-     && p->zKey[nToken+1]==0 
     ){
       break;
     }
@@ -173816,15 +175195,18 @@ static int sqlite3Fts5HashWrite(
 
   /* If an existing hash entry cannot be found, create a new one. */
   if( p==0 ){
+    /* Figure out how much space to allocate */
     int nByte = FTS5_HASHENTRYSIZE + (nToken+1) + 1 + 64;
     if( nByte<128 ) nByte = 128;
 
+    /* Grow the Fts5Hash.aSlot[] array if necessary. */
     if( (pHash->nEntry*2)>=pHash->nSlot ){
       int rc = fts5HashResize(pHash);
       if( rc!=SQLITE_OK ) return rc;
       iHash = fts5HashKey2(pHash->nSlot, (u8)bByte, (const u8*)pToken, nToken);
     }
 
+    /* Allocate new Fts5HashEntry and add it to the hash table. */
     p = (Fts5HashEntry*)sqlite3_malloc(nByte);
     if( !p ) return SQLITE_NOMEM;
     memset(p, 0, FTS5_HASHENTRYSIZE);
@@ -173832,72 +175214,98 @@ static int sqlite3Fts5HashWrite(
     p->zKey[0] = bByte;
     memcpy(&p->zKey[1], pToken, nToken);
     assert( iHash==fts5HashKey(pHash->nSlot, (u8*)p->zKey, nToken+1) );
+    p->nKey = nToken;
     p->zKey[nToken+1] = '\0';
     p->nData = nToken+1 + 1 + FTS5_HASHENTRYSIZE;
-    p->nData += sqlite3Fts5PutVarint(&((u8*)p)[p->nData], iRowid);
-    p->iSzPoslist = p->nData;
-    p->nData += 1;
-    p->iRowid = iRowid;
     p->pHashNext = pHash->aSlot[iHash];
     pHash->aSlot[iHash] = p;
     pHash->nEntry++;
-    nIncr += p->nData;
-  }
 
-  /* Check there is enough space to append a new entry. Worst case scenario
-  ** is:
-  **
-  **     + 9 bytes for a new rowid,
-  **     + 4 byte reserved for the "poslist size" varint.
-  **     + 1 byte for a "new column" byte,
-  **     + 3 bytes for a new column number (16-bit max) as a varint,
-  **     + 5 bytes for the new position offset (32-bit max).
-  */
-  if( (p->nAlloc - p->nData) < (9 + 4 + 1 + 3 + 5) ){
-    int nNew = p->nAlloc * 2;
-    Fts5HashEntry *pNew;
-    Fts5HashEntry **pp;
-    pNew = (Fts5HashEntry*)sqlite3_realloc(p, nNew);
-    if( pNew==0 ) return SQLITE_NOMEM;
-    pNew->nAlloc = nNew;
-    for(pp=&pHash->aSlot[iHash]; *pp!=p; pp=&(*pp)->pHashNext);
-    *pp = pNew;
-    p = pNew;
+    /* Add the first rowid field to the hash-entry */
+    p->nData += sqlite3Fts5PutVarint(&((u8*)p)[p->nData], iRowid);
+    p->iRowid = iRowid;
+
+    p->iSzPoslist = p->nData;
+    if( pHash->eDetail!=FTS5_DETAIL_NONE ){
+      p->nData += 1;
+      p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
+    }
+
+    nIncr += p->nData;
+  }else{
+
+    /* Appending to an existing hash-entry. Check that there is enough 
+    ** space to append the largest possible new entry. Worst case scenario 
+    ** is:
+    **
+    **     + 9 bytes for a new rowid,
+    **     + 4 byte reserved for the "poslist size" varint.
+    **     + 1 byte for a "new column" byte,
+    **     + 3 bytes for a new column number (16-bit max) as a varint,
+    **     + 5 bytes for the new position offset (32-bit max).
+    */
+    if( (p->nAlloc - p->nData) < (9 + 4 + 1 + 3 + 5) ){
+      int nNew = p->nAlloc * 2;
+      Fts5HashEntry *pNew;
+      Fts5HashEntry **pp;
+      pNew = (Fts5HashEntry*)sqlite3_realloc(p, nNew);
+      if( pNew==0 ) return SQLITE_NOMEM;
+      pNew->nAlloc = nNew;
+      for(pp=&pHash->aSlot[iHash]; *pp!=p; pp=&(*pp)->pHashNext);
+      *pp = pNew;
+      p = pNew;
+    }
+    nIncr -= p->nData;
   }
+  assert( (p->nAlloc - p->nData) >= (9 + 4 + 1 + 3 + 5) );
+
   pPtr = (u8*)p;
-  nIncr -= p->nData;
 
   /* If this is a new rowid, append the 4-byte size field for the previous
   ** entry, and the new rowid for this entry.  */
   if( iRowid!=p->iRowid ){
-    fts5HashAddPoslistSize(p);
+    fts5HashAddPoslistSize(pHash, p);
     p->nData += sqlite3Fts5PutVarint(&pPtr[p->nData], iRowid - p->iRowid);
-    p->iSzPoslist = p->nData;
-    p->nData += 1;
-    p->iCol = 0;
-    p->iPos = 0;
     p->iRowid = iRowid;
+    bNew = 1;
+    p->iSzPoslist = p->nData;
+    if( pHash->eDetail!=FTS5_DETAIL_NONE ){
+      p->nData += 1;
+      p->iCol = (pHash->eDetail==FTS5_DETAIL_FULL ? 0 : -1);
+      p->iPos = 0;
+    }
   }
 
   if( iCol>=0 ){
-    /* Append a new column value, if necessary */
-    assert( iCol>=p->iCol );
-    if( iCol!=p->iCol ){
-      pPtr[p->nData++] = 0x01;
-      p->nData += sqlite3Fts5PutVarint(&pPtr[p->nData], iCol);
-      p->iCol = iCol;
-      p->iPos = 0;
-    }
+    if( pHash->eDetail==FTS5_DETAIL_NONE ){
+      p->bContent = 1;
+    }else{
+      /* Append a new column value, if necessary */
+      assert( iCol>=p->iCol );
+      if( iCol!=p->iCol ){
+        if( pHash->eDetail==FTS5_DETAIL_FULL ){
+          pPtr[p->nData++] = 0x01;
+          p->nData += sqlite3Fts5PutVarint(&pPtr[p->nData], iCol);
+          p->iCol = iCol;
+          p->iPos = 0;
+        }else{
+          bNew = 1;
+          p->iCol = iPos = iCol;
+        }
+      }
 
-    /* Append the new position offset */
-    p->nData += sqlite3Fts5PutVarint(&pPtr[p->nData], iPos - p->iPos + 2);
-    p->iPos = iPos;
+      /* Append the new position offset, if necessary */
+      if( bNew ){
+        p->nData += sqlite3Fts5PutVarint(&pPtr[p->nData], iPos - p->iPos + 2);
+        p->iPos = iPos;
+      }
+    }
   }else{
     /* This is a delete. Set the delete flag. */
     p->bDel = 1;
   }
-  nIncr += p->nData;
 
+  nIncr += p->nData;
   *pHash->pnByte += nIncr;
   return SQLITE_OK;
 }
@@ -174011,7 +175419,7 @@ static int sqlite3Fts5HashQuery(
   }
 
   if( p ){
-    fts5HashAddPoslistSize(p);
+    fts5HashAddPoslistSize(pHash, p);
     *ppDoclist = (const u8*)&p->zKey[nTerm+1];
     *pnDoclist = p->nData - (FTS5_HASHENTRYSIZE + nTerm + 1);
   }else{
@@ -174047,7 +175455,7 @@ static void sqlite3Fts5HashScanEntry(
   Fts5HashEntry *p;
   if( (p = pHash->pScan) ){
     int nTerm = (int)strlen(p->zKey);
-    fts5HashAddPoslistSize(p);
+    fts5HashAddPoslistSize(pHash, p);
     *pzTerm = p->zKey;
     *ppDoclist = (const u8*)&p->zKey[nTerm+1];
     *pnDoclist = p->nData - (FTS5_HASHENTRYSIZE + nTerm + 1);
@@ -174322,6 +175730,7 @@ typedef struct Fts5Data Fts5Data;
 typedef struct Fts5DlidxIter Fts5DlidxIter;
 typedef struct Fts5DlidxLvl Fts5DlidxLvl;
 typedef struct Fts5DlidxWriter Fts5DlidxWriter;
+typedef struct Fts5Iter Fts5Iter;
 typedef struct Fts5PageWriter Fts5PageWriter;
 typedef struct Fts5SegIter Fts5SegIter;
 typedef struct Fts5DoclistIter Fts5DoclistIter;
@@ -174494,6 +175903,9 @@ struct Fts5SegIter {
   Fts5Data *pNextLeaf;            /* Leaf page (iLeafPgno+1) */
   int iLeafOffset;                /* Byte offset within current leaf */
 
+  /* Next method */
+  void (*xNext)(Fts5Index*, Fts5SegIter*, int*);
+
   /* The page and offset from which the current term was read. The offset 
   ** is the offset of the first rowid in the current doclist.  */
   int iTermLeafPgno;
@@ -174513,7 +175925,7 @@ struct Fts5SegIter {
   Fts5Buffer term;                /* Current term */
   i64 iRowid;                     /* Current rowid */
   int nPos;                       /* Number of bytes in current position list */
-  int bDel;                       /* True if the delete flag is set */
+  u8 bDel;                        /* True if the delete flag is set */
 };
 
 /*
@@ -174527,7 +175939,6 @@ struct Fts5SegIter {
 #define FTS5_SEGITER_ONETERM 0x01
 #define FTS5_SEGITER_REVERSE 0x02
 
-
 /* 
 ** Argument is a pointer to an Fts5Data structure that contains a leaf
 ** page. This macro evaluates to true if the leaf contains no terms, or
@@ -174562,16 +175973,20 @@ struct Fts5SegIter {
 **   Used by sqlite3Fts5IterPoslist() when the poslist needs to be buffered.
 **   There is no way to tell if this is populated or not.
 */
-struct Fts5IndexIter {
+struct Fts5Iter {
+  Fts5IndexIter base;             /* Base class containing output vars */
+
   Fts5Index *pIndex;              /* Index that owns this iterator */
   Fts5Structure *pStruct;         /* Database structure for this iterator */
   Fts5Buffer poslist;             /* Buffer containing current poslist */
+  Fts5Colset *pColset;            /* Restrict matches to these columns */
+
+  /* Invoked to set output variables. */
+  void (*xSetOutputs)(Fts5Iter*, Fts5SegIter*);
 
   int nSeg;                       /* Size of aSeg[] array */
   int bRev;                       /* True to iterate in reverse order */
   u8 bSkipEmpty;                  /* True to skip deleted entries */
-  u8 bEof;                        /* True at EOF */
-  u8 bFiltered;                   /* True if column-filter already applied */
 
   i64 iSwitchRowid;               /* Firstest rowid of other than aFirst[1] */
   Fts5CResult *aFirst;            /* Current merge state (see above) */
@@ -174661,17 +176076,6 @@ static int fts5BufferCompare(Fts5Buffer *pLeft, Fts5Buffer *pRight){
   return (res==0 ? (pLeft->n - pRight->n) : res);
 }
 
-#ifdef SQLITE_DEBUG
-static int fts5BlobCompare(
-  const u8 *pLeft, int nLeft, 
-  const u8 *pRight, int nRight
-){
-  int nCmp = MIN(nLeft, nRight);
-  int res = memcmp(pLeft, pRight, nCmp);
-  return (res==0 ? (nLeft - nRight) : res);
-}
-#endif
-
 static int fts5LeafFirstTermOff(Fts5Data *pLeaf){
   int ret;
   fts5GetVarint32(&pLeaf->p[pLeaf->szLeaf], ret);
@@ -174763,6 +176167,7 @@ static Fts5Data *fts5DataRead(Fts5Index *p, i64 iRowid){
   return pRet;
 }
 
+
 /*
 ** Release a reference to data record returned by an earlier call to
 ** fts5DataRead().
@@ -174933,25 +176338,34 @@ static int fts5StructureDecode(
       int nTotal;
       int iSeg;
 
-      i += fts5GetVarint32(&pData[i], pLvl->nMerge);
-      i += fts5GetVarint32(&pData[i], nTotal);
-      assert( nTotal>=pLvl->nMerge );
-      pLvl->aSeg = (Fts5StructureSegment*)sqlite3Fts5MallocZero(&rc, 
-          nTotal * sizeof(Fts5StructureSegment)
-      );
+      if( i>=nData ){
+        rc = FTS5_CORRUPT;
+      }else{
+        i += fts5GetVarint32(&pData[i], pLvl->nMerge);
+        i += fts5GetVarint32(&pData[i], nTotal);
+        assert( nTotal>=pLvl->nMerge );
+        pLvl->aSeg = (Fts5StructureSegment*)sqlite3Fts5MallocZero(&rc, 
+            nTotal * sizeof(Fts5StructureSegment)
+        );
+      }
 
       if( rc==SQLITE_OK ){
         pLvl->nSeg = nTotal;
         for(iSeg=0; iSeg<nTotal; iSeg++){
+          if( i>=nData ){
+            rc = FTS5_CORRUPT;
+            break;
+          }
           i += fts5GetVarint32(&pData[i], pLvl->aSeg[iSeg].iSegid);
           i += fts5GetVarint32(&pData[i], pLvl->aSeg[iSeg].pgnoFirst);
           i += fts5GetVarint32(&pData[i], pLvl->aSeg[iSeg].pgnoLast);
         }
-      }else{
-        fts5StructureRelease(pRet);
-        pRet = 0;
       }
     }
+    if( rc!=SQLITE_OK ){
+      fts5StructureRelease(pRet);
+      pRet = 0;
+    }
   }
 
   *ppOut = pRet;
@@ -175553,13 +176967,29 @@ static int fts5GetPoslistSize(const u8 *p, int *pnSz, int *pbDel){
 static void fts5SegIterLoadNPos(Fts5Index *p, Fts5SegIter *pIter){
   if( p->rc==SQLITE_OK ){
     int iOff = pIter->iLeafOffset;  /* Offset to read at */
-    int nSz;
     ASSERT_SZLEAF_OK(pIter->pLeaf);
-    fts5FastGetVarint32(pIter->pLeaf->p, iOff, nSz);
-    pIter->bDel = (nSz & 0x0001);
-    pIter->nPos = nSz>>1;
+    if( p->pConfig->eDetail==FTS5_DETAIL_NONE ){
+      int iEod = MIN(pIter->iEndofDoclist, pIter->pLeaf->szLeaf);
+      pIter->bDel = 0;
+      pIter->nPos = 1;
+      if( iOff<iEod && pIter->pLeaf->p[iOff]==0 ){
+        pIter->bDel = 1;
+        iOff++;
+        if( iOff<iEod && pIter->pLeaf->p[iOff]==0 ){
+          pIter->nPos = 1;
+          iOff++;
+        }else{
+          pIter->nPos = 0;
+        }
+      }
+    }else{
+      int nSz;
+      fts5FastGetVarint32(pIter->pLeaf->p, iOff, nSz);
+      pIter->bDel = (nSz & 0x0001);
+      pIter->nPos = nSz>>1;
+      assert_nc( pIter->nPos>=0 );
+    }
     pIter->iLeafOffset = iOff;
-    assert_nc( pIter->nPos>=0 );
   }
 }
 
@@ -175602,6 +177032,10 @@ static void fts5SegIterLoadTerm(Fts5Index *p, Fts5SegIter *pIter, int nKeep){
   int nNew;                       /* Bytes of new data */
 
   iOff += fts5GetVarint32(&a[iOff], nNew);
+  if( iOff+nNew>pIter->pLeaf->nn ){
+    p->rc = FTS5_CORRUPT;
+    return;
+  }
   pIter->term.n = nKeep;
   fts5BufferAppendBlob(&p->rc, &pIter->term, nNew, &a[iOff]);
   iOff += nNew;
@@ -175620,6 +177054,20 @@ static void fts5SegIterLoadTerm(Fts5Index *p, Fts5SegIter *pIter, int nKeep){
   fts5SegIterLoadRowid(p, pIter);
 }
 
+static void fts5SegIterNext(Fts5Index*, Fts5SegIter*, int*);
+static void fts5SegIterNext_Reverse(Fts5Index*, Fts5SegIter*, int*);
+static void fts5SegIterNext_None(Fts5Index*, Fts5SegIter*, int*);
+
+static void fts5SegIterSetNext(Fts5Index *p, Fts5SegIter *pIter){
+  if( pIter->flags & FTS5_SEGITER_REVERSE ){
+    pIter->xNext = fts5SegIterNext_Reverse;
+  }else if( p->pConfig->eDetail==FTS5_DETAIL_NONE ){
+    pIter->xNext = fts5SegIterNext_None;
+  }else{
+    pIter->xNext = fts5SegIterNext;
+  }
+}
+
 /*
 ** Initialize the iterator object pIter to iterate through the entries in
 ** segment pSeg. The iterator is left pointing to the first entry when 
@@ -175645,6 +177093,7 @@ static void fts5SegIterInit(
 
   if( p->rc==SQLITE_OK ){
     memset(pIter, 0, sizeof(*pIter));
+    fts5SegIterSetNext(p, pIter);
     pIter->pSeg = pSeg;
     pIter->iLeafPgno = pSeg->pgnoFirst-1;
     fts5SegIterNextPage(p, pIter);
@@ -175676,6 +177125,7 @@ static void fts5SegIterInit(
 ** byte of the position list content associated with said rowid.
 */
 static void fts5SegIterReverseInitPage(Fts5Index *p, Fts5SegIter *pIter){
+  int eDetail = p->pConfig->eDetail;
   int n = pIter->pLeaf->szLeaf;
   int i = pIter->iLeafOffset;
   u8 *a = pIter->pLeaf->p;
@@ -175688,15 +177138,24 @@ static void fts5SegIterReverseInitPage(Fts5Index *p, Fts5SegIter *pIter){
   ASSERT_SZLEAF_OK(pIter->pLeaf);
   while( 1 ){
     i64 iDelta = 0;
-    int nPos;
-    int bDummy;
 
-    i += fts5GetPoslistSize(&a[i], &nPos, &bDummy);
-    i += nPos;
+    if( eDetail==FTS5_DETAIL_NONE ){
+      /* todo */
+      if( i<n && a[i]==0 ){
+        i++;
+        if( i<n && a[i]==0 ) i++;
+      }
+    }else{
+      int nPos;
+      int bDummy;
+      i += fts5GetPoslistSize(&a[i], &nPos, &bDummy);
+      i += nPos;
+    }
     if( i>=n ) break;
     i += fts5GetVarint(&a[i], (u64*)&iDelta);
     pIter->iRowid += iDelta;
 
+    /* If necessary, grow the pIter->aRowidOffset[] array. */
     if( iRowidOffset>=pIter->nRowidOffset ){
       int nNew = pIter->nRowidOffset + 8;
       int *aNew = (int*)sqlite3_realloc(pIter->aRowidOffset, nNew*sizeof(int));
@@ -175770,11 +177229,115 @@ static void fts5SegIterReverseNewPage(Fts5Index *p, Fts5SegIter *pIter){
 ** points to a delete marker. A delete marker is an entry with a 0 byte
 ** position-list.
 */
-static int fts5MultiIterIsEmpty(Fts5Index *p, Fts5IndexIter *pIter){
+static int fts5MultiIterIsEmpty(Fts5Index *p, Fts5Iter *pIter){
   Fts5SegIter *pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
   return (p->rc==SQLITE_OK && pSeg->pLeaf && pSeg->nPos==0);
 }
 
+/*
+** Advance iterator pIter to the next entry.
+**
+** This version of fts5SegIterNext() is only used by reverse iterators.
+*/
+static void fts5SegIterNext_Reverse(
+  Fts5Index *p,                   /* FTS5 backend object */
+  Fts5SegIter *pIter,             /* Iterator to advance */
+  int *pbUnused                   /* Unused */
+){
+  assert( pIter->flags & FTS5_SEGITER_REVERSE );
+  assert( pIter->pNextLeaf==0 );
+  UNUSED_PARAM(pbUnused);
+
+  if( pIter->iRowidOffset>0 ){
+    u8 *a = pIter->pLeaf->p;
+    int iOff;
+    i64 iDelta;
+
+    pIter->iRowidOffset--;
+    pIter->iLeafOffset = pIter->aRowidOffset[pIter->iRowidOffset];
+    fts5SegIterLoadNPos(p, pIter);
+    iOff = pIter->iLeafOffset;
+    if( p->pConfig->eDetail!=FTS5_DETAIL_NONE ){
+      iOff += pIter->nPos;
+    }
+    fts5GetVarint(&a[iOff], (u64*)&iDelta);
+    pIter->iRowid -= iDelta;
+  }else{
+    fts5SegIterReverseNewPage(p, pIter);
+  }
+}
+
+/*
+** Advance iterator pIter to the next entry.
+**
+** This version of fts5SegIterNext() is only used if detail=none and the
+** iterator is not a reverse direction iterator.
+*/
+static void fts5SegIterNext_None(
+  Fts5Index *p,                   /* FTS5 backend object */
+  Fts5SegIter *pIter,             /* Iterator to advance */
+  int *pbNewTerm                  /* OUT: Set for new term */
+){
+  int iOff;
+
+  assert( p->rc==SQLITE_OK );
+  assert( (pIter->flags & FTS5_SEGITER_REVERSE)==0 );
+  assert( p->pConfig->eDetail==FTS5_DETAIL_NONE );
+
+  ASSERT_SZLEAF_OK(pIter->pLeaf);
+  iOff = pIter->iLeafOffset;
+
+  /* Next entry is on the next page */
+  if( pIter->pSeg && iOff>=pIter->pLeaf->szLeaf ){
+    fts5SegIterNextPage(p, pIter);
+    if( p->rc || pIter->pLeaf==0 ) return;
+    pIter->iRowid = 0;
+    iOff = 4;
+  }
+
+  if( iOff<pIter->iEndofDoclist ){
+    /* Next entry is on the current page */
+    i64 iDelta;
+    iOff += sqlite3Fts5GetVarint(&pIter->pLeaf->p[iOff], (u64*)&iDelta);
+    pIter->iLeafOffset = iOff;
+    pIter->iRowid += iDelta;
+  }else if( (pIter->flags & FTS5_SEGITER_ONETERM)==0 ){
+    if( pIter->pSeg ){
+      int nKeep = 0;
+      if( iOff!=fts5LeafFirstTermOff(pIter->pLeaf) ){
+        iOff += fts5GetVarint32(&pIter->pLeaf->p[iOff], nKeep);
+      }
+      pIter->iLeafOffset = iOff;
+      fts5SegIterLoadTerm(p, pIter, nKeep);
+    }else{
+      const u8 *pList = 0;
+      const char *zTerm = 0;
+      int nList;
+      sqlite3Fts5HashScanNext(p->pHash);
+      sqlite3Fts5HashScanEntry(p->pHash, &zTerm, &pList, &nList);
+      if( pList==0 ) goto next_none_eof;
+      pIter->pLeaf->p = (u8*)pList;
+      pIter->pLeaf->nn = nList;
+      pIter->pLeaf->szLeaf = nList;
+      pIter->iEndofDoclist = nList;
+      sqlite3Fts5BufferSet(&p->rc,&pIter->term, (int)strlen(zTerm), (u8*)zTerm);
+      pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
+    }
+
+    if( pbNewTerm ) *pbNewTerm = 1;
+  }else{
+    goto next_none_eof;
+  }
+
+  fts5SegIterLoadNPos(p, pIter);
+
+  return;
+ next_none_eof:
+  fts5DataRelease(pIter->pLeaf);
+  pIter->pLeaf = 0;
+}
+
+
 /*
 ** Advance iterator pIter to the next entry. 
 **
@@ -175787,141 +177350,132 @@ static void fts5SegIterNext(
   Fts5SegIter *pIter,             /* Iterator to advance */
   int *pbNewTerm                  /* OUT: Set for new term */
 ){
-  assert( pbNewTerm==0 || *pbNewTerm==0 );
-  if( p->rc==SQLITE_OK ){
-    if( pIter->flags & FTS5_SEGITER_REVERSE ){
-      assert( pIter->pNextLeaf==0 );
-      if( pIter->iRowidOffset>0 ){
-        u8 *a = pIter->pLeaf->p;
-        int iOff;
-        int nPos;
-        int bDummy;
-        i64 iDelta;
+  Fts5Data *pLeaf = pIter->pLeaf;
+  int iOff;
+  int bNewTerm = 0;
+  int nKeep = 0;
+  u8 *a;
+  int n;
 
-        pIter->iRowidOffset--;
-        pIter->iLeafOffset = iOff = pIter->aRowidOffset[pIter->iRowidOffset];
-        iOff += fts5GetPoslistSize(&a[iOff], &nPos, &bDummy);
-        iOff += nPos;
-        fts5GetVarint(&a[iOff], (u64*)&iDelta);
-        pIter->iRowid -= iDelta;
-        fts5SegIterLoadNPos(p, pIter);
-      }else{
-        fts5SegIterReverseNewPage(p, pIter);
+  assert( pbNewTerm==0 || *pbNewTerm==0 );
+  assert( p->pConfig->eDetail!=FTS5_DETAIL_NONE );
+
+  /* Search for the end of the position list within the current page. */
+  a = pLeaf->p;
+  n = pLeaf->szLeaf;
+
+  ASSERT_SZLEAF_OK(pLeaf);
+  iOff = pIter->iLeafOffset + pIter->nPos;
+
+  if( iOff<n ){
+    /* The next entry is on the current page. */
+    assert_nc( iOff<=pIter->iEndofDoclist );
+    if( iOff>=pIter->iEndofDoclist ){
+      bNewTerm = 1;
+      if( iOff!=fts5LeafFirstTermOff(pLeaf) ){
+        iOff += fts5GetVarint32(&a[iOff], nKeep);
       }
     }else{
-      Fts5Data *pLeaf = pIter->pLeaf;
-      int iOff;
-      int bNewTerm = 0;
-      int nKeep = 0;
-
-      /* Search for the end of the position list within the current page. */
-      u8 *a = pLeaf->p;
-      int n = pLeaf->szLeaf;
+      u64 iDelta;
+      iOff += sqlite3Fts5GetVarint(&a[iOff], &iDelta);
+      pIter->iRowid += iDelta;
+      assert_nc( iDelta>0 );
+    }
+    pIter->iLeafOffset = iOff;
 
+  }else if( pIter->pSeg==0 ){
+    const u8 *pList = 0;
+    const char *zTerm = 0;
+    int nList = 0;
+    assert( (pIter->flags & FTS5_SEGITER_ONETERM) || pbNewTerm );
+    if( 0==(pIter->flags & FTS5_SEGITER_ONETERM) ){
+      sqlite3Fts5HashScanNext(p->pHash);
+      sqlite3Fts5HashScanEntry(p->pHash, &zTerm, &pList, &nList);
+    }
+    if( pList==0 ){
+      fts5DataRelease(pIter->pLeaf);
+      pIter->pLeaf = 0;
+    }else{
+      pIter->pLeaf->p = (u8*)pList;
+      pIter->pLeaf->nn = nList;
+      pIter->pLeaf->szLeaf = nList;
+      pIter->iEndofDoclist = nList+1;
+      sqlite3Fts5BufferSet(&p->rc, &pIter->term, (int)strlen(zTerm),
+          (u8*)zTerm);
+      pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
+      *pbNewTerm = 1;
+    }
+  }else{
+    iOff = 0;
+    /* Next entry is not on the current page */
+    while( iOff==0 ){
+      fts5SegIterNextPage(p, pIter);
+      pLeaf = pIter->pLeaf;
+      if( pLeaf==0 ) break;
       ASSERT_SZLEAF_OK(pLeaf);
-      iOff = pIter->iLeafOffset + pIter->nPos;
-
-      if( iOff<n ){
-        /* The next entry is on the current page. */
-        assert_nc( iOff<=pIter->iEndofDoclist );
-        if( iOff>=pIter->iEndofDoclist ){
-          bNewTerm = 1;
-          if( iOff!=fts5LeafFirstTermOff(pLeaf) ){
-            iOff += fts5GetVarint32(&a[iOff], nKeep);
-          }
-        }else{
-          u64 iDelta;
-          iOff += sqlite3Fts5GetVarint(&a[iOff], &iDelta);
-          pIter->iRowid += iDelta;
-          assert_nc( iDelta>0 );
-        }
+      if( (iOff = fts5LeafFirstRowidOff(pLeaf)) && iOff<pLeaf->szLeaf ){
+        iOff += sqlite3Fts5GetVarint(&pLeaf->p[iOff], (u64*)&pIter->iRowid);
         pIter->iLeafOffset = iOff;
 
-      }else if( pIter->pSeg==0 ){
-        const u8 *pList = 0;
-        const char *zTerm = 0;
-        int nList = 0;
-        assert( (pIter->flags & FTS5_SEGITER_ONETERM) || pbNewTerm );
-        if( 0==(pIter->flags & FTS5_SEGITER_ONETERM) ){
-          sqlite3Fts5HashScanNext(p->pHash);
-          sqlite3Fts5HashScanEntry(p->pHash, &zTerm, &pList, &nList);
-        }
-        if( pList==0 ){
-          fts5DataRelease(pIter->pLeaf);
-          pIter->pLeaf = 0;
-        }else{
-          pIter->pLeaf->p = (u8*)pList;
-          pIter->pLeaf->nn = nList;
-          pIter->pLeaf->szLeaf = nList;
-          pIter->iEndofDoclist = nList+1;
-          sqlite3Fts5BufferSet(&p->rc, &pIter->term, (int)strlen(zTerm),
-              (u8*)zTerm);
-          pIter->iLeafOffset = fts5GetVarint(pList, (u64*)&pIter->iRowid);
-          *pbNewTerm = 1;
-        }
-      }else{
-        iOff = 0;
-        /* Next entry is not on the current page */
-        while( iOff==0 ){
-          fts5SegIterNextPage(p, pIter);
-          pLeaf = pIter->pLeaf;
-          if( pLeaf==0 ) break;
-          ASSERT_SZLEAF_OK(pLeaf);
-          if( (iOff = fts5LeafFirstRowidOff(pLeaf)) && iOff<pLeaf->szLeaf ){
-            iOff += sqlite3Fts5GetVarint(&pLeaf->p[iOff], (u64*)&pIter->iRowid);
-            pIter->iLeafOffset = iOff;
-
-            if( pLeaf->nn>pLeaf->szLeaf ){
-              pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
-                  &pLeaf->p[pLeaf->szLeaf], pIter->iEndofDoclist
+        if( pLeaf->nn>pLeaf->szLeaf ){
+          pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
+              &pLeaf->p[pLeaf->szLeaf], pIter->iEndofDoclist
               );
-            }
+        }
 
-          }
-          else if( pLeaf->nn>pLeaf->szLeaf ){
-            pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
-                &pLeaf->p[pLeaf->szLeaf], iOff
+      }
+      else if( pLeaf->nn>pLeaf->szLeaf ){
+        pIter->iPgidxOff = pLeaf->szLeaf + fts5GetVarint32(
+            &pLeaf->p[pLeaf->szLeaf], iOff
             );
-            pIter->iLeafOffset = iOff;
-            pIter->iEndofDoclist = iOff;
-            bNewTerm = 1;
-          }
-          if( iOff>=pLeaf->szLeaf ){
-            p->rc = FTS5_CORRUPT;
-            return;
-          }
-        }
+        pIter->iLeafOffset = iOff;
+        pIter->iEndofDoclist = iOff;
+        bNewTerm = 1;
       }
+      assert_nc( iOff<pLeaf->szLeaf );
+      if( iOff>pLeaf->szLeaf ){
+        p->rc = FTS5_CORRUPT;
+        return;
+      }
+    }
+  }
 
-      /* Check if the iterator is now at EOF. If so, return early. */
-      if( pIter->pLeaf ){
-        if( bNewTerm ){
-          if( pIter->flags & FTS5_SEGITER_ONETERM ){
-            fts5DataRelease(pIter->pLeaf);
-            pIter->pLeaf = 0;
-          }else{
-            fts5SegIterLoadTerm(p, pIter, nKeep);
-            fts5SegIterLoadNPos(p, pIter);
-            if( pbNewTerm ) *pbNewTerm = 1;
-          }
-        }else{
-          /* The following could be done by calling fts5SegIterLoadNPos(). But
-          ** this block is particularly performance critical, so equivalent
-          ** code is inlined. */
-          int nSz;
-          assert( p->rc==SQLITE_OK );
-          fts5FastGetVarint32(pIter->pLeaf->p, pIter->iLeafOffset, nSz);
-          pIter->bDel = (nSz & 0x0001);
-          pIter->nPos = nSz>>1;
-          assert_nc( pIter->nPos>=0 );
-        }
+  /* Check if the iterator is now at EOF. If so, return early. */
+  if( pIter->pLeaf ){
+    if( bNewTerm ){
+      if( pIter->flags & FTS5_SEGITER_ONETERM ){
+        fts5DataRelease(pIter->pLeaf);
+        pIter->pLeaf = 0;
+      }else{
+        fts5SegIterLoadTerm(p, pIter, nKeep);
+        fts5SegIterLoadNPos(p, pIter);
+        if( pbNewTerm ) *pbNewTerm = 1;
       }
+    }else{
+      /* The following could be done by calling fts5SegIterLoadNPos(). But
+      ** this block is particularly performance critical, so equivalent
+      ** code is inlined. 
+      **
+      ** Later: Switched back to fts5SegIterLoadNPos() because it supports
+      ** detail=none mode. Not ideal.
+      */
+      int nSz;
+      assert( p->rc==SQLITE_OK );
+      fts5FastGetVarint32(pIter->pLeaf->p, pIter->iLeafOffset, nSz);
+      pIter->bDel = (nSz & 0x0001);
+      pIter->nPos = nSz>>1;
+      assert_nc( pIter->nPos>=0 );
     }
   }
 }
 
 #define SWAPVAL(T, a, b) { T tmp; tmp=a; a=b; b=tmp; }
 
+#define fts5IndexSkipVarint(a, iOff) {            \
+  int iEnd = iOff+9;                              \
+  while( (a[iOff++] & 0x80) && iOff<iEnd );       \
+}
+
 /*
 ** Iterator pIter currently points to the first rowid in a doclist. This
 ** function sets the iterator up so that iterates in reverse order through
@@ -175942,7 +177496,14 @@ static void fts5SegIterReverse(Fts5Index *p, Fts5SegIter *pIter){
     /* Currently, Fts5SegIter.iLeafOffset points to the first byte of
     ** position-list content for the current rowid. Back it up so that it
     ** points to the start of the position-list size field. */
-    pIter->iLeafOffset -= sqlite3Fts5GetVarintLen(pIter->nPos*2+pIter->bDel);
+    int iPoslist;
+    if( pIter->iTermLeafPgno==pIter->iLeafPgno ){
+      iPoslist = pIter->iTermLeafOffset;
+    }else{
+      iPoslist = 4;
+    }
+    fts5IndexSkipVarint(pLeaf->p, iPoslist);
+    pIter->iLeafOffset = iPoslist;
 
     /* If this condition is true then the largest rowid for the current
     ** term may not be stored on the current page. So search forward to
@@ -176026,11 +177587,6 @@ static void fts5SegIterLoadDlidx(Fts5Index *p, Fts5SegIter *pIter){
   pIter->pDlidx = fts5DlidxIterInit(p, bRev, iSeg, pIter->iTermLeafPgno);
 }
 
-#define fts5IndexSkipVarint(a, iOff) {            \
-  int iEnd = iOff+9;                              \
-  while( (a[iOff++] & 0x80) && iOff<iEnd );       \
-}
-
 /*
 ** The iterator object passed as the second argument currently contains
 ** no valid values except for the Fts5SegIter.pLeaf member variable. This
@@ -176068,6 +177624,10 @@ static void fts5LeafSeek(
   iPgidx = szLeaf;
   iPgidx += fts5GetVarint32(&a[iPgidx], iTermOff);
   iOff = iTermOff;
+  if( iOff>n ){
+    p->rc = FTS5_CORRUPT;
+    return;
+  }
 
   while( 1 ){
 
@@ -176168,7 +177728,6 @@ static void fts5LeafSeek(
 */
 static void fts5SegIterSeekInit(
   Fts5Index *p,                   /* FTS5 backend */
-  Fts5Buffer *pBuf,               /* Buffer to use for loading pages */
   const u8 *pTerm, int nTerm,     /* Term to seek to */
   int flags,                      /* Mask of FTS5INDEX_XXX flags */
   Fts5StructureSegment *pSeg,     /* Description of segment */
@@ -176178,9 +177737,6 @@ static void fts5SegIterSeekInit(
   int bGe = (flags & FTS5INDEX_QUERY_SCAN);
   int bDlidx = 0;                 /* True if there is a doclist-index */
 
-  static int nCall = 0;
-  nCall++;
-
   assert( bGe==0 || (flags & FTS5INDEX_QUERY_DESC)==0 );
   assert( pTerm && nTerm );
   memset(pIter, 0, sizeof(*pIter));
@@ -176233,6 +177789,8 @@ static void fts5SegIterSeekInit(
     }
   }
 
+  fts5SegIterSetNext(p, pIter);
+
   /* Either:
   **
   **   1) an error has occurred, or
@@ -176290,7 +177848,7 @@ static void fts5SegIterHashInit(
     pLeaf->nn = pLeaf->szLeaf = nList;
     pIter->pLeaf = pLeaf;
     pIter->iLeafOffset = fts5GetVarint(pLeaf->p, (u64*)&pIter->iRowid);
-    pIter->iEndofDoclist = pLeaf->nn+1;
+    pIter->iEndofDoclist = pLeaf->nn;
 
     if( flags & FTS5INDEX_QUERY_DESC ){
       pIter->flags |= FTS5_SEGITER_REVERSE;
@@ -176299,6 +177857,8 @@ static void fts5SegIterHashInit(
       fts5SegIterLoadNPos(p, pIter);
     }
   }
+
+  fts5SegIterSetNext(p, pIter);
 }
 
 /*
@@ -176322,7 +177882,7 @@ static void fts5SegIterClear(Fts5SegIter *pIter){
 ** two iterators.
 */
 static void fts5AssertComparisonResult(
-  Fts5IndexIter *pIter, 
+  Fts5Iter *pIter, 
   Fts5SegIter *p1,
   Fts5SegIter *p2,
   Fts5CResult *pRes
@@ -176363,12 +177923,12 @@ static void fts5AssertComparisonResult(
 ** statement used to verify that the contents of the pIter->aFirst[] array
 ** are correct.
 */
-static void fts5AssertMultiIterSetup(Fts5Index *p, Fts5IndexIter *pIter){
+static void fts5AssertMultiIterSetup(Fts5Index *p, Fts5Iter *pIter){
   if( p->rc==SQLITE_OK ){
     Fts5SegIter *pFirst = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
     int i;
 
-    assert( (pFirst->pLeaf==0)==pIter->bEof );
+    assert( (pFirst->pLeaf==0)==pIter->base.bEof );
 
     /* Check that pIter->iSwitchRowid is set correctly. */
     for(i=0; i<pIter->nSeg; i++){
@@ -176408,7 +177968,7 @@ static void fts5AssertMultiIterSetup(Fts5Index *p, Fts5IndexIter *pIter){
 ** to a key that is a duplicate of another, higher priority, 
 ** segment-iterator in the pSeg->aSeg[] array.
 */
-static int fts5MultiIterDoCompare(Fts5IndexIter *pIter, int iOut){
+static int fts5MultiIterDoCompare(Fts5Iter *pIter, int iOut){
   int i1;                         /* Index of left-hand Fts5SegIter */
   int i2;                         /* Index of right-hand Fts5SegIter */
   int iRes;
@@ -176542,7 +178102,7 @@ static void fts5SegIterNextFrom(
   }
 
   do{
-    if( bMove ) fts5SegIterNext(p, pIter, 0);
+    if( bMove && p->rc==SQLITE_OK ) pIter->xNext(p, pIter, 0);
     if( pIter->pLeaf==0 ) break;
     if( bRev==0 && pIter->iRowid>=iMatch ) break;
     if( bRev!=0 && pIter->iRowid<=iMatch ) break;
@@ -176554,7 +178114,7 @@ static void fts5SegIterNextFrom(
 /*
 ** Free the iterator object passed as the second argument.
 */
-static void fts5MultiIterFree(Fts5Index *p, Fts5IndexIter *pIter){
+static void fts5MultiIterFree(Fts5Iter *pIter){
   if( pIter ){
     int i;
     for(i=0; i<pIter->nSeg; i++){
@@ -176568,7 +178128,7 @@ static void fts5MultiIterFree(Fts5Index *p, Fts5IndexIter *pIter){
 
 static void fts5MultiIterAdvanced(
   Fts5Index *p,                   /* FTS5 backend to iterate within */
-  Fts5IndexIter *pIter,           /* Iterator to update aFirst[] array for */
+  Fts5Iter *pIter,                /* Iterator to update aFirst[] array for */
   int iChanged,                   /* Index of sub-iterator just advanced */
   int iMinset                     /* Minimum entry in aFirst[] to set */
 ){
@@ -176576,7 +178136,9 @@ static void fts5MultiIterAdvanced(
   for(i=(pIter->nSeg+iChanged)/2; i>=iMinset && p->rc==SQLITE_OK; i=i/2){
     int iEq;
     if( (iEq = fts5MultiIterDoCompare(pIter, i)) ){
-      fts5SegIterNext(p, &pIter->aSeg[iEq], 0);
+      Fts5SegIter *pSeg = &pIter->aSeg[iEq];
+      assert( p->rc==SQLITE_OK );
+      pSeg->xNext(p, pSeg, 0);
       i = pIter->nSeg + iEq;
     }
   }
@@ -176593,9 +178155,9 @@ static void fts5MultiIterAdvanced(
 ** that it deals with more complicated cases as well.
 */ 
 static int fts5MultiIterAdvanceRowid(
-  Fts5Index *p,                   /* FTS5 backend to iterate within */
-  Fts5IndexIter *pIter,           /* Iterator to update aFirst[] array for */
-  int iChanged                    /* Index of sub-iterator just advanced */
+  Fts5Iter *pIter,                /* Iterator to update aFirst[] array for */
+  int iChanged,                   /* Index of sub-iterator just advanced */
+  Fts5SegIter **ppFirst
 ){
   Fts5SegIter *pNew = &pIter->aSeg[iChanged];
 
@@ -176628,15 +178190,16 @@ static int fts5MultiIterAdvanceRowid(
     }
   }
 
+  *ppFirst = pNew;
   return 0;
 }
 
 /*
 ** Set the pIter->bEof variable based on the state of the sub-iterators.
 */
-static void fts5MultiIterSetEof(Fts5IndexIter *pIter){
+static void fts5MultiIterSetEof(Fts5Iter *pIter){
   Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
-  pIter->bEof = pSeg->pLeaf==0;
+  pIter->base.bEof = pSeg->pLeaf==0;
   pIter->iSwitchRowid = pSeg->iRowid;
 }
 
@@ -176649,39 +178212,44 @@ static void fts5MultiIterSetEof(Fts5IndexIter *pIter){
 */
 static void fts5MultiIterNext(
   Fts5Index *p, 
-  Fts5IndexIter *pIter,
+  Fts5Iter *pIter,
   int bFrom,                      /* True if argument iFrom is valid */
   i64 iFrom                       /* Advance at least as far as this */
 ){
-  if( p->rc==SQLITE_OK ){
-    int bUseFrom = bFrom;
-    do {
-      int iFirst = pIter->aFirst[1].iFirst;
-      int bNewTerm = 0;
-      Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
-      assert( p->rc==SQLITE_OK );
-      if( bUseFrom && pSeg->pDlidx ){
-        fts5SegIterNextFrom(p, pSeg, iFrom);
-      }else{
-        fts5SegIterNext(p, pSeg, &bNewTerm);
-      }
+  int bUseFrom = bFrom;
+  while( p->rc==SQLITE_OK ){
+    int iFirst = pIter->aFirst[1].iFirst;
+    int bNewTerm = 0;
+    Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
+    assert( p->rc==SQLITE_OK );
+    if( bUseFrom && pSeg->pDlidx ){
+      fts5SegIterNextFrom(p, pSeg, iFrom);
+    }else{
+      pSeg->xNext(p, pSeg, &bNewTerm);
+    }
 
-      if( pSeg->pLeaf==0 || bNewTerm 
-       || fts5MultiIterAdvanceRowid(p, pIter, iFirst)
-      ){
-        fts5MultiIterAdvanced(p, pIter, iFirst, 1);
-        fts5MultiIterSetEof(pIter);
-      }
-      fts5AssertMultiIterSetup(p, pIter);
+    if( pSeg->pLeaf==0 || bNewTerm 
+     || fts5MultiIterAdvanceRowid(pIter, iFirst, &pSeg)
+    ){
+      fts5MultiIterAdvanced(p, pIter, iFirst, 1);
+      fts5MultiIterSetEof(pIter);
+      pSeg = &pIter->aSeg[pIter->aFirst[1].iFirst];
+      if( pSeg->pLeaf==0 ) return;
+    }
 
-      bUseFrom = 0;
-    }while( pIter->bSkipEmpty && fts5MultiIterIsEmpty(p, pIter) );
+    fts5AssertMultiIterSetup(p, pIter);
+    assert( pSeg==&pIter->aSeg[pIter->aFirst[1].iFirst] && pSeg->pLeaf );
+    if( pIter->bSkipEmpty==0 || pSeg->nPos ){
+      pIter->xSetOutputs(pIter, pSeg);
+      return;
+    }
+    bUseFrom = 0;
   }
 }
 
 static void fts5MultiIterNext2(
   Fts5Index *p, 
-  Fts5IndexIter *pIter,
+  Fts5Iter *pIter,
   int *pbNewTerm                  /* OUT: True if *might* be new term */
 ){
   assert( pIter->bSkipEmpty );
@@ -176691,9 +178259,10 @@ static void fts5MultiIterNext2(
       Fts5SegIter *pSeg = &pIter->aSeg[iFirst];
       int bNewTerm = 0;
 
-      fts5SegIterNext(p, pSeg, &bNewTerm);
+      assert( p->rc==SQLITE_OK );
+      pSeg->xNext(p, pSeg, &bNewTerm);
       if( pSeg->pLeaf==0 || bNewTerm 
-       || fts5MultiIterAdvanceRowid(p, pIter, iFirst)
+       || fts5MultiIterAdvanceRowid(pIter, iFirst, &pSeg)
       ){
         fts5MultiIterAdvanced(p, pIter, iFirst, 1);
         fts5MultiIterSetEof(pIter);
@@ -176707,17 +178276,20 @@ static void fts5MultiIterNext2(
   }
 }
 
+static void fts5IterSetOutputs_Noop(Fts5Iter *pUnused1, Fts5SegIter *pUnused2){
+  UNUSED_PARAM2(pUnused1, pUnused2);
+}
 
-static Fts5IndexIter *fts5MultiIterAlloc(
+static Fts5Iter *fts5MultiIterAlloc(
   Fts5Index *p,                   /* FTS5 backend to iterate within */
   int nSeg
 ){
-  Fts5IndexIter *pNew;
+  Fts5Iter *pNew;
   int nSlot;                      /* Power of two >= nSeg */
 
   for(nSlot=2; nSlot<nSeg; nSlot=nSlot*2);
   pNew = fts5IdxMalloc(p, 
-      sizeof(Fts5IndexIter) +             /* pNew */
+      sizeof(Fts5Iter) +                  /* pNew */
       sizeof(Fts5SegIter) * (nSlot-1) +   /* pNew->aSeg[] */
       sizeof(Fts5CResult) * nSlot         /* pNew->aFirst[] */
   );
@@ -176725,196 +178297,122 @@ static Fts5IndexIter *fts5MultiIterAlloc(
     pNew->nSeg = nSlot;
     pNew->aFirst = (Fts5CResult*)&pNew->aSeg[nSlot];
     pNew->pIndex = p;
+    pNew->xSetOutputs = fts5IterSetOutputs_Noop;
   }
   return pNew;
 }
 
-/*
-** Allocate a new Fts5IndexIter object.
-**
-** The new object will be used to iterate through data in structure pStruct.
-** If iLevel is -ve, then all data in all segments is merged. Or, if iLevel
-** is zero or greater, data from the first nSegment segments on level iLevel
-** is merged.
-**
-** The iterator initially points to the first term/rowid entry in the 
-** iterated data.
-*/
-static void fts5MultiIterNew(
-  Fts5Index *p,                   /* FTS5 backend to iterate within */
-  Fts5Structure *pStruct,         /* Structure of specific index */
-  int bSkipEmpty,                 /* True to ignore delete-keys */
-  int flags,                      /* FTS5INDEX_QUERY_XXX flags */
-  const u8 *pTerm, int nTerm,     /* Term to seek to (or NULL/0) */
-  int iLevel,                     /* Level to iterate (-1 for all) */
-  int nSegment,                   /* Number of segments to merge (iLevel>=0) */
-  Fts5IndexIter **ppOut           /* New object */
+static void fts5PoslistCallback(
+  Fts5Index *pUnused, 
+  void *pContext, 
+  const u8 *pChunk, int nChunk
 ){
-  int nSeg = 0;                   /* Number of segment-iters in use */
-  int iIter = 0;                  /* */
-  int iSeg;                       /* Used to iterate through segments */
-  Fts5Buffer buf = {0,0,0};       /* Buffer used by fts5SegIterSeekInit() */
-  Fts5StructureLevel *pLvl;
-  Fts5IndexIter *pNew;
+  UNUSED_PARAM(pUnused);
+  assert_nc( nChunk>=0 );
+  if( nChunk>0 ){
+    fts5BufferSafeAppendBlob((Fts5Buffer*)pContext, pChunk, nChunk);
+  }
+}
 
-  assert( (pTerm==0 && nTerm==0) || iLevel<0 );
+typedef struct PoslistCallbackCtx PoslistCallbackCtx;
+struct PoslistCallbackCtx {
+  Fts5Buffer *pBuf;               /* Append to this buffer */
+  Fts5Colset *pColset;            /* Restrict matches to this column */
+  int eState;                     /* See above */
+};
 
-  /* Allocate space for the new multi-seg-iterator. */
-  if( p->rc==SQLITE_OK ){
-    if( iLevel<0 ){
-      assert( pStruct->nSegment==fts5StructureCountSegments(pStruct) );
-      nSeg = pStruct->nSegment;
-      nSeg += (p->pHash ? 1 : 0);
-    }else{
-      nSeg = MIN(pStruct->aLevel[iLevel].nSeg, nSegment);
+typedef struct PoslistOffsetsCtx PoslistOffsetsCtx;
+struct PoslistOffsetsCtx {
+  Fts5Buffer *pBuf;               /* Append to this buffer */
+  Fts5Colset *pColset;            /* Restrict matches to this column */
+  int iRead;
+  int iWrite;
+};
+
+/*
+** TODO: Make this more efficient!
+*/
+static int fts5IndexColsetTest(Fts5Colset *pColset, int iCol){
+  int i;
+  for(i=0; i<pColset->nCol; i++){
+    if( pColset->aiCol[i]==iCol ) return 1;
+  }
+  return 0;
+}
+
+static void fts5PoslistOffsetsCallback(
+  Fts5Index *pUnused, 
+  void *pContext, 
+  const u8 *pChunk, int nChunk
+){
+  PoslistOffsetsCtx *pCtx = (PoslistOffsetsCtx*)pContext;
+  UNUSED_PARAM(pUnused);
+  assert_nc( nChunk>=0 );
+  if( nChunk>0 ){
+    int i = 0;
+    while( i<nChunk ){
+      int iVal;
+      i += fts5GetVarint32(&pChunk[i], iVal);
+      iVal += pCtx->iRead - 2;
+      pCtx->iRead = iVal;
+      if( fts5IndexColsetTest(pCtx->pColset, iVal) ){
+        fts5BufferSafeAppendVarint(pCtx->pBuf, iVal + 2 - pCtx->iWrite);
+        pCtx->iWrite = iVal;
+      }
     }
   }
-  *ppOut = pNew = fts5MultiIterAlloc(p, nSeg);
-  if( pNew==0 ) return;
-  pNew->bRev = (0!=(flags & FTS5INDEX_QUERY_DESC));
-  pNew->bSkipEmpty = (u8)bSkipEmpty;
-  pNew->pStruct = pStruct;
-  fts5StructureRef(pStruct);
+}
 
-  /* Initialize each of the component segment iterators. */
-  if( iLevel<0 ){
-    Fts5StructureLevel *pEnd = &pStruct->aLevel[pStruct->nLevel];
-    if( p->pHash ){
-      /* Add a segment iterator for the current contents of the hash table. */
-      Fts5SegIter *pIter = &pNew->aSeg[iIter++];
-      fts5SegIterHashInit(p, pTerm, nTerm, flags, pIter);
+static void fts5PoslistFilterCallback(
+  Fts5Index *pUnused,
+  void *pContext, 
+  const u8 *pChunk, int nChunk
+){
+  PoslistCallbackCtx *pCtx = (PoslistCallbackCtx*)pContext;
+  UNUSED_PARAM(pUnused);
+  assert_nc( nChunk>=0 );
+  if( nChunk>0 ){
+    /* Search through to find the first varint with value 1. This is the
+    ** start of the next columns hits. */
+    int i = 0;
+    int iStart = 0;
+
+    if( pCtx->eState==2 ){
+      int iCol;
+      fts5FastGetVarint32(pChunk, i, iCol);
+      if( fts5IndexColsetTest(pCtx->pColset, iCol) ){
+        pCtx->eState = 1;
+        fts5BufferSafeAppendVarint(pCtx->pBuf, 1);
+      }else{
+        pCtx->eState = 0;
+      }
     }
-    for(pLvl=&pStruct->aLevel[0]; pLvl<pEnd; pLvl++){
-      for(iSeg=pLvl->nSeg-1; iSeg>=0; iSeg--){
-        Fts5StructureSegment *pSeg = &pLvl->aSeg[iSeg];
-        Fts5SegIter *pIter = &pNew->aSeg[iIter++];
-        if( pTerm==0 ){
-          fts5SegIterInit(p, pSeg, pIter);
+
+    do {
+      while( i<nChunk && pChunk[i]!=0x01 ){
+        while( pChunk[i] & 0x80 ) i++;
+        i++;
+      }
+      if( pCtx->eState ){
+        fts5BufferSafeAppendBlob(pCtx->pBuf, &pChunk[iStart], i-iStart);
+      }
+      if( i<nChunk ){
+        int iCol;
+        iStart = i;
+        i++;
+        if( i>=nChunk ){
+          pCtx->eState = 2;
         }else{
-          fts5SegIterSeekInit(p, &buf, pTerm, nTerm, flags, pSeg, pIter);
+          fts5FastGetVarint32(pChunk, i, iCol);
+          pCtx->eState = fts5IndexColsetTest(pCtx->pColset, iCol);
+          if( pCtx->eState ){
+            fts5BufferSafeAppendBlob(pCtx->pBuf, &pChunk[iStart], i-iStart);
+            iStart = i;
+          }
         }
       }
-    }
-  }else{
-    pLvl = &pStruct->aLevel[iLevel];
-    for(iSeg=nSeg-1; iSeg>=0; iSeg--){
-      fts5SegIterInit(p, &pLvl->aSeg[iSeg], &pNew->aSeg[iIter++]);
-    }
+    }while( i<nChunk );
   }
-  assert( iIter==nSeg );
-
-  /* If the above was successful, each component iterators now points 
-  ** to the first entry in its segment. In this case initialize the 
-  ** aFirst[] array. Or, if an error has occurred, free the iterator
-  ** object and set the output variable to NULL.  */
-  if( p->rc==SQLITE_OK ){
-    for(iIter=pNew->nSeg-1; iIter>0; iIter--){
-      int iEq;
-      if( (iEq = fts5MultiIterDoCompare(pNew, iIter)) ){
-        fts5SegIterNext(p, &pNew->aSeg[iEq], 0);
-        fts5MultiIterAdvanced(p, pNew, iEq, iIter);
-      }
-    }
-    fts5MultiIterSetEof(pNew);
-    fts5AssertMultiIterSetup(p, pNew);
-
-    if( pNew->bSkipEmpty && fts5MultiIterIsEmpty(p, pNew) ){
-      fts5MultiIterNext(p, pNew, 0, 0);
-    }
-  }else{
-    fts5MultiIterFree(p, pNew);
-    *ppOut = 0;
-  }
-  fts5BufferFree(&buf);
-}
-
-/*
-** Create an Fts5IndexIter that iterates through the doclist provided
-** as the second argument.
-*/
-static void fts5MultiIterNew2(
-  Fts5Index *p,                   /* FTS5 backend to iterate within */
-  Fts5Data *pData,                /* Doclist to iterate through */
-  int bDesc,                      /* True for descending rowid order */
-  Fts5IndexIter **ppOut           /* New object */
-){
-  Fts5IndexIter *pNew;
-  pNew = fts5MultiIterAlloc(p, 2);
-  if( pNew ){
-    Fts5SegIter *pIter = &pNew->aSeg[1];
-
-    pNew->bFiltered = 1;
-    pIter->flags = FTS5_SEGITER_ONETERM;
-    if( pData->szLeaf>0 ){
-      pIter->pLeaf = pData;
-      pIter->iLeafOffset = fts5GetVarint(pData->p, (u64*)&pIter->iRowid);
-      pIter->iEndofDoclist = pData->nn;
-      pNew->aFirst[1].iFirst = 1;
-      if( bDesc ){
-        pNew->bRev = 1;
-        pIter->flags |= FTS5_SEGITER_REVERSE;
-        fts5SegIterReverseInitPage(p, pIter);
-      }else{
-        fts5SegIterLoadNPos(p, pIter);
-      }
-      pData = 0;
-    }else{
-      pNew->bEof = 1;
-    }
-
-    *ppOut = pNew;
-  }
-
-  fts5DataRelease(pData);
-}
-
-/*
-** Return true if the iterator is at EOF or if an error has occurred. 
-** False otherwise.
-*/
-static int fts5MultiIterEof(Fts5Index *p, Fts5IndexIter *pIter){
-  assert( p->rc 
-      || (pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf==0)==pIter->bEof 
-  );
-  return (p->rc || pIter->bEof);
-}
-
-/*
-** Return the rowid of the entry that the iterator currently points
-** to. If the iterator points to EOF when this function is called the
-** results are undefined.
-*/
-static i64 fts5MultiIterRowid(Fts5IndexIter *pIter){
-  assert( pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf );
-  return pIter->aSeg[ pIter->aFirst[1].iFirst ].iRowid;
-}
-
-/*
-** Move the iterator to the next entry at or following iMatch.
-*/
-static void fts5MultiIterNextFrom(
-  Fts5Index *p, 
-  Fts5IndexIter *pIter, 
-  i64 iMatch
-){
-  while( 1 ){
-    i64 iRowid;
-    fts5MultiIterNext(p, pIter, 1, iMatch);
-    if( fts5MultiIterEof(p, pIter) ) break;
-    iRowid = fts5MultiIterRowid(pIter);
-    if( pIter->bRev==0 && iRowid>=iMatch ) break;
-    if( pIter->bRev!=0 && iRowid<=iMatch ) break;
-  }
-}
-
-/*
-** Return a pointer to a buffer containing the term associated with the 
-** entry that the iterator currently points to.
-*/
-static const u8 *fts5MultiIterTerm(Fts5IndexIter *pIter, int *pn){
-  Fts5SegIter *p = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
-  *pn = p->term.n;
-  return p->term.p;
 }
 
 static void fts5ChunkIterate(
@@ -176930,6 +178428,9 @@ static void fts5ChunkIterate(
   int pgno = pSeg->iLeafPgno;
   int pgnoSave = 0;
 
+  /* This function does notmwork with detail=none databases. */
+  assert( p->pConfig->eDetail!=FTS5_DETAIL_NONE );
+
   if( (pSeg->flags & FTS5_SEGITER_REVERSE)==0 ){
     pgnoSave = pgno+1;
   }
@@ -176955,7 +178456,455 @@ static void fts5ChunkIterate(
   }
 }
 
+/*
+** Iterator pIter currently points to a valid entry (not EOF). This
+** function appends the position list data for the current entry to
+** buffer pBuf. It does not make a copy of the position-list size
+** field.
+*/
+static void fts5SegiterPoslist(
+  Fts5Index *p,
+  Fts5SegIter *pSeg,
+  Fts5Colset *pColset,
+  Fts5Buffer *pBuf
+){
+  if( 0==fts5BufferGrow(&p->rc, pBuf, pSeg->nPos) ){
+    if( pColset==0 ){
+      fts5ChunkIterate(p, pSeg, (void*)pBuf, fts5PoslistCallback);
+    }else{
+      if( p->pConfig->eDetail==FTS5_DETAIL_FULL ){
+        PoslistCallbackCtx sCtx;
+        sCtx.pBuf = pBuf;
+        sCtx.pColset = pColset;
+        sCtx.eState = fts5IndexColsetTest(pColset, 0);
+        assert( sCtx.eState==0 || sCtx.eState==1 );
+        fts5ChunkIterate(p, pSeg, (void*)&sCtx, fts5PoslistFilterCallback);
+      }else{
+        PoslistOffsetsCtx sCtx;
+        memset(&sCtx, 0, sizeof(sCtx));
+        sCtx.pBuf = pBuf;
+        sCtx.pColset = pColset;
+        fts5ChunkIterate(p, pSeg, (void*)&sCtx, fts5PoslistOffsetsCallback);
+      }
+    }
+  }
+}
 
+/*
+** IN/OUT parameter (*pa) points to a position list n bytes in size. If
+** the position list contains entries for column iCol, then (*pa) is set
+** to point to the sub-position-list for that column and the number of
+** bytes in it returned. Or, if the argument position list does not
+** contain any entries for column iCol, return 0.
+*/
+static int fts5IndexExtractCol(
+  const u8 **pa,                  /* IN/OUT: Pointer to poslist */
+  int n,                          /* IN: Size of poslist in bytes */
+  int iCol                        /* Column to extract from poslist */
+){
+  int iCurrent = 0;               /* Anything before the first 0x01 is col 0 */
+  const u8 *p = *pa;
+  const u8 *pEnd = &p[n];         /* One byte past end of position list */
+
+  while( iCol>iCurrent ){
+    /* Advance pointer p until it points to pEnd or an 0x01 byte that is
+    ** not part of a varint. Note that it is not possible for a negative
+    ** or extremely large varint to occur within an uncorrupted position 
+    ** list. So the last byte of each varint may be assumed to have a clear
+    ** 0x80 bit.  */
+    while( *p!=0x01 ){
+      while( *p++ & 0x80 );
+      if( p>=pEnd ) return 0;
+    }
+    *pa = p++;
+    iCurrent = *p++;
+    if( iCurrent & 0x80 ){
+      p--;
+      p += fts5GetVarint32(p, iCurrent);
+    }
+  }
+  if( iCol!=iCurrent ) return 0;
+
+  /* Advance pointer p until it points to pEnd or an 0x01 byte that is
+  ** not part of a varint */
+  while( p<pEnd && *p!=0x01 ){
+    while( *p++ & 0x80 );
+  }
+
+  return p - (*pa);
+}
+
+static int fts5IndexExtractColset (
+  Fts5Colset *pColset,            /* Colset to filter on */
+  const u8 *pPos, int nPos,       /* Position list */
+  Fts5Buffer *pBuf                /* Output buffer */
+){
+  int rc = SQLITE_OK;
+  int i;
+
+  fts5BufferZero(pBuf);
+  for(i=0; i<pColset->nCol; i++){
+    const u8 *pSub = pPos;
+    int nSub = fts5IndexExtractCol(&pSub, nPos, pColset->aiCol[i]);
+    if( nSub ){
+      fts5BufferAppendBlob(&rc, pBuf, nSub, pSub);
+    }
+  }
+  return rc;
+}
+
+/*
+** xSetOutputs callback used by detail=none tables.
+*/
+static void fts5IterSetOutputs_None(Fts5Iter *pIter, Fts5SegIter *pSeg){
+  assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_NONE );
+  pIter->base.iRowid = pSeg->iRowid;
+  pIter->base.nData = pSeg->nPos;
+}
+
+/*
+** xSetOutputs callback used by detail=full and detail=col tables when no
+** column filters are specified.
+*/
+static void fts5IterSetOutputs_Nocolset(Fts5Iter *pIter, Fts5SegIter *pSeg){
+  pIter->base.iRowid = pSeg->iRowid;
+  pIter->base.nData = pSeg->nPos;
+
+  assert( pIter->pIndex->pConfig->eDetail!=FTS5_DETAIL_NONE );
+  assert( pIter->pColset==0 );
+
+  if( pSeg->iLeafOffset+pSeg->nPos<=pSeg->pLeaf->szLeaf ){
+    /* All data is stored on the current page. Populate the output 
+    ** variables to point into the body of the page object. */
+    pIter->base.pData = &pSeg->pLeaf->p[pSeg->iLeafOffset];
+  }else{
+    /* The data is distributed over two or more pages. Copy it into the
+    ** Fts5Iter.poslist buffer and then set the output pointer to point
+    ** to this buffer.  */
+    fts5BufferZero(&pIter->poslist);
+    fts5SegiterPoslist(pIter->pIndex, pSeg, 0, &pIter->poslist);
+    pIter->base.pData = pIter->poslist.p;
+  }
+}
+
+/*
+** xSetOutputs callback used by detail=col when there is a column filter
+** and there are 100 or more columns. Also called as a fallback from
+** fts5IterSetOutputs_Col100 if the column-list spans more than one page.
+*/
+static void fts5IterSetOutputs_Col(Fts5Iter *pIter, Fts5SegIter *pSeg){
+  fts5BufferZero(&pIter->poslist);
+  fts5SegiterPoslist(pIter->pIndex, pSeg, pIter->pColset, &pIter->poslist);
+  pIter->base.iRowid = pSeg->iRowid;
+  pIter->base.pData = pIter->poslist.p;
+  pIter->base.nData = pIter->poslist.n;
+}
+
+/*
+** xSetOutputs callback used when: 
+**
+**   * detail=col,
+**   * there is a column filter, and
+**   * the table contains 100 or fewer columns. 
+**
+** The last point is to ensure all column numbers are stored as 
+** single-byte varints.
+*/
+static void fts5IterSetOutputs_Col100(Fts5Iter *pIter, Fts5SegIter *pSeg){
+
+  assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_COLUMNS );
+  assert( pIter->pColset );
+
+  if( pSeg->iLeafOffset+pSeg->nPos>pSeg->pLeaf->szLeaf ){
+    fts5IterSetOutputs_Col(pIter, pSeg);
+  }else{
+    u8 *a = (u8*)&pSeg->pLeaf->p[pSeg->iLeafOffset];
+    u8 *pEnd = (u8*)&a[pSeg->nPos]; 
+    int iPrev = 0;
+    int *aiCol = pIter->pColset->aiCol;
+    int *aiColEnd = &aiCol[pIter->pColset->nCol];
+
+    u8 *aOut = pIter->poslist.p;
+    int iPrevOut = 0;
+
+    pIter->base.iRowid = pSeg->iRowid;
+
+    while( a<pEnd ){
+      iPrev += (int)a++[0] - 2;
+      while( *aiCol<iPrev ){
+        aiCol++;
+        if( aiCol==aiColEnd ) goto setoutputs_col_out;
+      }
+      if( *aiCol==iPrev ){
+        *aOut++ = (iPrev - iPrevOut) + 2;
+        iPrevOut = iPrev;
+      }
+    }
+
+setoutputs_col_out:
+    pIter->base.pData = pIter->poslist.p;
+    pIter->base.nData = aOut - pIter->poslist.p;
+  }
+}
+
+/*
+** xSetOutputs callback used by detail=full when there is a column filter.
+*/
+static void fts5IterSetOutputs_Full(Fts5Iter *pIter, Fts5SegIter *pSeg){
+  Fts5Colset *pColset = pIter->pColset;
+  pIter->base.iRowid = pSeg->iRowid;
+
+  assert( pIter->pIndex->pConfig->eDetail==FTS5_DETAIL_FULL );
+  assert( pColset );
+
+  if( pSeg->iLeafOffset+pSeg->nPos<=pSeg->pLeaf->szLeaf ){
+    /* All data is stored on the current page. Populate the output 
+    ** variables to point into the body of the page object. */
+    const u8 *a = &pSeg->pLeaf->p[pSeg->iLeafOffset];
+    if( pColset->nCol==1 ){
+      pIter->base.nData = fts5IndexExtractCol(&a, pSeg->nPos,pColset->aiCol[0]);
+      pIter->base.pData = a;
+    }else{
+      fts5BufferZero(&pIter->poslist);
+      fts5IndexExtractColset(pColset, a, pSeg->nPos, &pIter->poslist);
+      pIter->base.pData = pIter->poslist.p;
+      pIter->base.nData = pIter->poslist.n;
+    }
+  }else{
+    /* The data is distributed over two or more pages. Copy it into the
+    ** Fts5Iter.poslist buffer and then set the output pointer to point
+    ** to this buffer.  */
+    fts5BufferZero(&pIter->poslist);
+    fts5SegiterPoslist(pIter->pIndex, pSeg, pColset, &pIter->poslist);
+    pIter->base.pData = pIter->poslist.p;
+    pIter->base.nData = pIter->poslist.n;
+  }
+}
+
+static void fts5IterSetOutputCb(int *pRc, Fts5Iter *pIter){
+  if( *pRc==SQLITE_OK ){
+    Fts5Config *pConfig = pIter->pIndex->pConfig;
+    if( pConfig->eDetail==FTS5_DETAIL_NONE ){
+      pIter->xSetOutputs = fts5IterSetOutputs_None;
+    }
+
+    else if( pIter->pColset==0 ){
+      pIter->xSetOutputs = fts5IterSetOutputs_Nocolset;
+    }
+
+    else if( pConfig->eDetail==FTS5_DETAIL_FULL ){
+      pIter->xSetOutputs = fts5IterSetOutputs_Full;
+    }
+
+    else{
+      assert( pConfig->eDetail==FTS5_DETAIL_COLUMNS );
+      if( pConfig->nCol<=100 ){
+        pIter->xSetOutputs = fts5IterSetOutputs_Col100;
+        sqlite3Fts5BufferSize(pRc, &pIter->poslist, pConfig->nCol);
+      }else{
+        pIter->xSetOutputs = fts5IterSetOutputs_Col;
+      }
+    }
+  }
+}
+
+
+/*
+** Allocate a new Fts5Iter object.
+**
+** The new object will be used to iterate through data in structure pStruct.
+** If iLevel is -ve, then all data in all segments is merged. Or, if iLevel
+** is zero or greater, data from the first nSegment segments on level iLevel
+** is merged.
+**
+** The iterator initially points to the first term/rowid entry in the 
+** iterated data.
+*/
+static void fts5MultiIterNew(
+  Fts5Index *p,                   /* FTS5 backend to iterate within */
+  Fts5Structure *pStruct,         /* Structure of specific index */
+  int flags,                      /* FTS5INDEX_QUERY_XXX flags */
+  Fts5Colset *pColset,            /* Colset to filter on (or NULL) */
+  const u8 *pTerm, int nTerm,     /* Term to seek to (or NULL/0) */
+  int iLevel,                     /* Level to iterate (-1 for all) */
+  int nSegment,                   /* Number of segments to merge (iLevel>=0) */
+  Fts5Iter **ppOut                /* New object */
+){
+  int nSeg = 0;                   /* Number of segment-iters in use */
+  int iIter = 0;                  /* */
+  int iSeg;                       /* Used to iterate through segments */
+  Fts5StructureLevel *pLvl;
+  Fts5Iter *pNew;
+
+  assert( (pTerm==0 && nTerm==0) || iLevel<0 );
+
+  /* Allocate space for the new multi-seg-iterator. */
+  if( p->rc==SQLITE_OK ){
+    if( iLevel<0 ){
+      assert( pStruct->nSegment==fts5StructureCountSegments(pStruct) );
+      nSeg = pStruct->nSegment;
+      nSeg += (p->pHash ? 1 : 0);
+    }else{
+      nSeg = MIN(pStruct->aLevel[iLevel].nSeg, nSegment);
+    }
+  }
+  *ppOut = pNew = fts5MultiIterAlloc(p, nSeg);
+  if( pNew==0 ) return;
+  pNew->bRev = (0!=(flags & FTS5INDEX_QUERY_DESC));
+  pNew->bSkipEmpty = (0!=(flags & FTS5INDEX_QUERY_SKIPEMPTY));
+  pNew->pStruct = pStruct;
+  pNew->pColset = pColset;
+  fts5StructureRef(pStruct);
+  if( (flags & FTS5INDEX_QUERY_NOOUTPUT)==0 ){
+    fts5IterSetOutputCb(&p->rc, pNew);
+  }
+
+  /* Initialize each of the component segment iterators. */
+  if( p->rc==SQLITE_OK ){
+    if( iLevel<0 ){
+      Fts5StructureLevel *pEnd = &pStruct->aLevel[pStruct->nLevel];
+      if( p->pHash ){
+        /* Add a segment iterator for the current contents of the hash table. */
+        Fts5SegIter *pIter = &pNew->aSeg[iIter++];
+        fts5SegIterHashInit(p, pTerm, nTerm, flags, pIter);
+      }
+      for(pLvl=&pStruct->aLevel[0]; pLvl<pEnd; pLvl++){
+        for(iSeg=pLvl->nSeg-1; iSeg>=0; iSeg--){
+          Fts5StructureSegment *pSeg = &pLvl->aSeg[iSeg];
+          Fts5SegIter *pIter = &pNew->aSeg[iIter++];
+          if( pTerm==0 ){
+            fts5SegIterInit(p, pSeg, pIter);
+          }else{
+            fts5SegIterSeekInit(p, pTerm, nTerm, flags, pSeg, pIter);
+          }
+        }
+      }
+    }else{
+      pLvl = &pStruct->aLevel[iLevel];
+      for(iSeg=nSeg-1; iSeg>=0; iSeg--){
+        fts5SegIterInit(p, &pLvl->aSeg[iSeg], &pNew->aSeg[iIter++]);
+      }
+    }
+    assert( iIter==nSeg );
+  }
+
+  /* If the above was successful, each component iterators now points 
+  ** to the first entry in its segment. In this case initialize the 
+  ** aFirst[] array. Or, if an error has occurred, free the iterator
+  ** object and set the output variable to NULL.  */
+  if( p->rc==SQLITE_OK ){
+    for(iIter=pNew->nSeg-1; iIter>0; iIter--){
+      int iEq;
+      if( (iEq = fts5MultiIterDoCompare(pNew, iIter)) ){
+        Fts5SegIter *pSeg = &pNew->aSeg[iEq];
+        if( p->rc==SQLITE_OK ) pSeg->xNext(p, pSeg, 0);
+        fts5MultiIterAdvanced(p, pNew, iEq, iIter);
+      }
+    }
+    fts5MultiIterSetEof(pNew);
+    fts5AssertMultiIterSetup(p, pNew);
+
+    if( pNew->bSkipEmpty && fts5MultiIterIsEmpty(p, pNew) ){
+      fts5MultiIterNext(p, pNew, 0, 0);
+    }else if( pNew->base.bEof==0 ){
+      Fts5SegIter *pSeg = &pNew->aSeg[pNew->aFirst[1].iFirst];
+      pNew->xSetOutputs(pNew, pSeg);
+    }
+
+  }else{
+    fts5MultiIterFree(pNew);
+    *ppOut = 0;
+  }
+}
+
+/*
+** Create an Fts5Iter that iterates through the doclist provided
+** as the second argument.
+*/
+static void fts5MultiIterNew2(
+  Fts5Index *p,                   /* FTS5 backend to iterate within */
+  Fts5Data *pData,                /* Doclist to iterate through */
+  int bDesc,                      /* True for descending rowid order */
+  Fts5Iter **ppOut                /* New object */
+){
+  Fts5Iter *pNew;
+  pNew = fts5MultiIterAlloc(p, 2);
+  if( pNew ){
+    Fts5SegIter *pIter = &pNew->aSeg[1];
+
+    pIter->flags = FTS5_SEGITER_ONETERM;
+    if( pData->szLeaf>0 ){
+      pIter->pLeaf = pData;
+      pIter->iLeafOffset = fts5GetVarint(pData->p, (u64*)&pIter->iRowid);
+      pIter->iEndofDoclist = pData->nn;
+      pNew->aFirst[1].iFirst = 1;
+      if( bDesc ){
+        pNew->bRev = 1;
+        pIter->flags |= FTS5_SEGITER_REVERSE;
+        fts5SegIterReverseInitPage(p, pIter);
+      }else{
+        fts5SegIterLoadNPos(p, pIter);
+      }
+      pData = 0;
+    }else{
+      pNew->base.bEof = 1;
+    }
+    fts5SegIterSetNext(p, pIter);
+
+    *ppOut = pNew;
+  }
+
+  fts5DataRelease(pData);
+}
+
+/*
+** Return true if the iterator is at EOF or if an error has occurred. 
+** False otherwise.
+*/
+static int fts5MultiIterEof(Fts5Index *p, Fts5Iter *pIter){
+  assert( p->rc 
+      || (pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf==0)==pIter->base.bEof 
+  );
+  return (p->rc || pIter->base.bEof);
+}
+
+/*
+** Return the rowid of the entry that the iterator currently points
+** to. If the iterator points to EOF when this function is called the
+** results are undefined.
+*/
+static i64 fts5MultiIterRowid(Fts5Iter *pIter){
+  assert( pIter->aSeg[ pIter->aFirst[1].iFirst ].pLeaf );
+  return pIter->aSeg[ pIter->aFirst[1].iFirst ].iRowid;
+}
+
+/*
+** Move the iterator to the next entry at or following iMatch.
+*/
+static void fts5MultiIterNextFrom(
+  Fts5Index *p, 
+  Fts5Iter *pIter, 
+  i64 iMatch
+){
+  while( 1 ){
+    i64 iRowid;
+    fts5MultiIterNext(p, pIter, 1, iMatch);
+    if( fts5MultiIterEof(p, pIter) ) break;
+    iRowid = fts5MultiIterRowid(pIter);
+    if( pIter->bRev==0 && iRowid>=iMatch ) break;
+    if( pIter->bRev!=0 && iRowid<=iMatch ) break;
+  }
+}
+
+/*
+** Return a pointer to a buffer containing the term associated with the 
+** entry that the iterator currently points to.
+*/
+static const u8 *fts5MultiIterTerm(Fts5Iter *pIter, int *pn){
+  Fts5SegIter *p = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
+  *pn = p->term.n;
+  return p->term.p;
+}
 
 /*
 ** Allocate a new segment-id for the structure pStruct. The new segment
@@ -177003,15 +178952,14 @@ static void fts5IndexDiscardData(Fts5Index *p){
 }
 
 /*
-** Return the size of the prefix, in bytes, that buffer (nNew/pNew) shares
-** with buffer (nOld/pOld).
+** Return the size of the prefix, in bytes, that buffer 
+** (pNew/<length-unknown>) shares with buffer (pOld/nOld).
+**
+** Buffer (pNew/<length-unknown>) is guaranteed to be greater 
+** than buffer (pOld/nOld).
 */
-static int fts5PrefixCompress(
-  int nOld, const u8 *pOld,
-  int nNew, const u8 *pNew
-){
+static int fts5PrefixCompress(int nOld, const u8 *pOld, const u8 *pNew){
   int i;
-  assert( fts5BlobCompare(pOld, nOld, pNew, nNew)<0 );
   for(i=0; i<nOld; i++){
     if( pOld[i]!=pNew[i] ) break;
   }
@@ -177321,13 +179269,13 @@ static void fts5WriteAppendTerm(
       ** inefficient, but still correct.  */
       int n = nTerm;
       if( pPage->term.n ){
-        n = 1 + fts5PrefixCompress(pPage->term.n, pPage->term.p, nTerm, pTerm);
+        n = 1 + fts5PrefixCompress(pPage->term.n, pPage->term.p, pTerm);
       }
       fts5WriteBtreeTerm(p, pWriter, n, pTerm);
       pPage = &pWriter->writer;
     }
   }else{
-    nPrefix = fts5PrefixCompress(pPage->term.n, pPage->term.p, nTerm, pTerm);
+    nPrefix = fts5PrefixCompress(pPage->term.n, pPage->term.p, pTerm);
     fts5BufferAppendVarint(&p->rc, &pPage->buf, nPrefix);
   }
 
@@ -177353,8 +179301,7 @@ static void fts5WriteAppendTerm(
 static void fts5WriteAppendRowid(
   Fts5Index *p, 
   Fts5SegWriter *pWriter,
-  i64 iRowid,
-  int nPos
+  i64 iRowid
 ){
   if( p->rc==SQLITE_OK ){
     Fts5PageWriter *pPage = &pWriter->writer;
@@ -177381,8 +179328,6 @@ static void fts5WriteAppendRowid(
     pWriter->iPrevRowid = iRowid;
     pWriter->bFirstRowidInDoclist = 0;
     pWriter->bFirstRowidInPage = 0;
-
-    fts5BufferAppendVarint(&p->rc, &pPage->buf, nPos);
   }
 }
 
@@ -177493,7 +179438,7 @@ static void fts5WriteInit(
 ** incremental merge operation. This function is called if the incremental
 ** merge step has finished but the input has not been completely exhausted.
 */
-static void fts5TrimSegments(Fts5Index *p, Fts5IndexIter *pIter){
+static void fts5TrimSegments(Fts5Index *p, Fts5Iter *pIter){
   int i;
   Fts5Buffer buf;
   memset(&buf, 0, sizeof(Fts5Buffer));
@@ -177571,13 +179516,15 @@ static void fts5IndexMergeLevel(
   Fts5Structure *pStruct = *ppStruct;
   Fts5StructureLevel *pLvl = &pStruct->aLevel[iLvl];
   Fts5StructureLevel *pLvlOut;
-  Fts5IndexIter *pIter = 0;       /* Iterator to read input data */
+  Fts5Iter *pIter = 0;       /* Iterator to read input data */
   int nRem = pnRem ? *pnRem : 0;  /* Output leaf pages left to write */
   int nInput;                     /* Number of input segments */
   Fts5SegWriter writer;           /* Writer object */
   Fts5StructureSegment *pSeg;     /* Output segment */
   Fts5Buffer term;
   int bOldest;                    /* True if the output segment is the oldest */
+  int eDetail = p->pConfig->eDetail;
+  const int flags = FTS5INDEX_QUERY_NOOUTPUT;
 
   assert( iLvl<pStruct->nLevel );
   assert( pLvl->nMerge<=pLvl->nSeg );
@@ -177622,7 +179569,7 @@ static void fts5IndexMergeLevel(
   bOldest = (pLvlOut->nSeg==1 && pStruct->nLevel==iLvl+2);
 
   assert( iLvl>=0 );
-  for(fts5MultiIterNew(p, pStruct, 0, 0, 0, 0, iLvl, nInput, &pIter);
+  for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, iLvl, nInput, &pIter);
       fts5MultiIterEof(p, pIter)==0;
       fts5MultiIterNext(p, pIter, 0, 0)
   ){
@@ -177647,11 +179594,21 @@ static void fts5IndexMergeLevel(
 
     /* Append the rowid to the output */
     /* WRITEPOSLISTSIZE */
-    nPos = pSegIter->nPos*2 + pSegIter->bDel;
-    fts5WriteAppendRowid(p, &writer, fts5MultiIterRowid(pIter), nPos);
+    fts5WriteAppendRowid(p, &writer, fts5MultiIterRowid(pIter));
 
-    /* Append the position-list data to the output */
-    fts5ChunkIterate(p, pSegIter, (void*)&writer, fts5MergeChunkCallback);
+    if( eDetail==FTS5_DETAIL_NONE ){
+      if( pSegIter->bDel ){
+        fts5BufferAppendVarint(&p->rc, &writer.writer.buf, 0);
+        if( pSegIter->nPos>0 ){
+          fts5BufferAppendVarint(&p->rc, &writer.writer.buf, 0);
+        }
+      }
+    }else{
+      /* Append the position-list data to the output */
+      nPos = pSegIter->nPos*2 + pSegIter->bDel;
+      fts5BufferAppendVarint(&p->rc, &writer.writer.buf, nPos);
+      fts5ChunkIterate(p, pSegIter, (void*)&writer, fts5MergeChunkCallback);
+    }
   }
 
   /* Flush the last leaf page to disk. Set the output segment b-tree height
@@ -177684,7 +179641,7 @@ static void fts5IndexMergeLevel(
     pLvl->nMerge = nInput;
   }
 
-  fts5MultiIterFree(p, pIter);
+  fts5MultiIterFree(pIter);
   fts5BufferFree(&term);
   if( pnRem ) *pnRem -= writer.nLeafWritten;
 }
@@ -177839,7 +179796,7 @@ static void fts5FlushOneHash(Fts5Index *p){
 
   if( iSegid ){
     const int pgsz = p->pConfig->pgsz;
-
+    int eDetail = p->pConfig->eDetail;
     Fts5StructureSegment *pSeg;   /* New segment within pStruct */
     Fts5Buffer *pBuf;             /* Buffer in which to assemble leaf page */
     Fts5Buffer *pPgidx;           /* Buffer in which to assemble pgidx */
@@ -177882,12 +179839,7 @@ static void fts5FlushOneHash(Fts5Index *p){
         ** loop iterates through the poslists that make up the current 
         ** doclist.  */
         while( p->rc==SQLITE_OK && iOff<nDoclist ){
-          int nPos;
-          int nCopy;
-          int bDummy;
           iOff += fts5GetVarint(&pDoclist[iOff], (u64*)&iDelta);
-          nCopy = fts5GetPoslistSize(&pDoclist[iOff], &nPos, &bDummy);
-          nCopy += nPos;
           iRowid += iDelta;
           
           if( writer.bFirstRowidInPage ){
@@ -177900,34 +179852,52 @@ static void fts5FlushOneHash(Fts5Index *p){
           }
           assert( pBuf->n<=pBuf->nSpace );
 
-          if( (pBuf->n + pPgidx->n + nCopy) <= pgsz ){
-            /* The entire poslist will fit on the current leaf. So copy
-            ** it in one go. */
-            fts5BufferSafeAppendBlob(pBuf, &pDoclist[iOff], nCopy);
-          }else{
-            /* The entire poslist will not fit on this leaf. So it needs
-            ** to be broken into sections. The only qualification being
-            ** that each varint must be stored contiguously.  */
-            const u8 *pPoslist = &pDoclist[iOff];
-            int iPos = 0;
-            while( p->rc==SQLITE_OK ){
-              int nSpace = pgsz - pBuf->n - pPgidx->n;
-              int n = 0;
-              if( (nCopy - iPos)<=nSpace ){
-                n = nCopy - iPos;
-              }else{
-                n = fts5PoslistPrefix(&pPoslist[iPos], nSpace);
+          if( eDetail==FTS5_DETAIL_NONE ){
+            if( iOff<nDoclist && pDoclist[iOff]==0 ){
+              pBuf->p[pBuf->n++] = 0;
+              iOff++;
+              if( iOff<nDoclist && pDoclist[iOff]==0 ){
+                pBuf->p[pBuf->n++] = 0;
+                iOff++;
               }
-              assert( n>0 );
-              fts5BufferSafeAppendBlob(pBuf, &pPoslist[iPos], n);
-              iPos += n;
-              if( (pBuf->n + pPgidx->n)>=pgsz ){
-                fts5WriteFlushLeaf(p, &writer);
-              }
-              if( iPos>=nCopy ) break;
             }
+            if( (pBuf->n + pPgidx->n)>=pgsz ){
+              fts5WriteFlushLeaf(p, &writer);
+            }
+          }else{
+            int bDummy;
+            int nPos;
+            int nCopy = fts5GetPoslistSize(&pDoclist[iOff], &nPos, &bDummy);
+            nCopy += nPos;
+            if( (pBuf->n + pPgidx->n + nCopy) <= pgsz ){
+              /* The entire poslist will fit on the current leaf. So copy
+              ** it in one go. */
+              fts5BufferSafeAppendBlob(pBuf, &pDoclist[iOff], nCopy);
+            }else{
+              /* The entire poslist will not fit on this leaf. So it needs
+              ** to be broken into sections. The only qualification being
+              ** that each varint must be stored contiguously.  */
+              const u8 *pPoslist = &pDoclist[iOff];
+              int iPos = 0;
+              while( p->rc==SQLITE_OK ){
+                int nSpace = pgsz - pBuf->n - pPgidx->n;
+                int n = 0;
+                if( (nCopy - iPos)<=nSpace ){
+                  n = nCopy - iPos;
+                }else{
+                  n = fts5PoslistPrefix(&pPoslist[iPos], nSpace);
+                }
+                assert( n>0 );
+                fts5BufferSafeAppendBlob(pBuf, &pPoslist[iPos], n);
+                iPos += n;
+                if( (pBuf->n + pPgidx->n)>=pgsz ){
+                  fts5WriteFlushLeaf(p, &writer);
+                }
+                if( iPos>=nCopy ) break;
+              }
+            }
+            iOff += nCopy;
           }
-          iOff += nCopy;
         }
       }
 
@@ -178003,7 +179973,10 @@ static int sqlite3Fts5IndexOptimize(Fts5Index *p){
     if( pLvl->aSeg ){
       int iLvl, iSeg;
       int iSegOut = 0;
-      for(iLvl=0; iLvl<pStruct->nLevel; iLvl++){
+      /* Iterate through all segments, from oldest to newest. Add them to
+      ** the new Fts5Level object so that pLvl->aSeg[0] is the oldest
+      ** segment in the data structure.  */
+      for(iLvl=pStruct->nLevel-1; iLvl>=0; iLvl--){
         for(iSeg=0; iSeg<pStruct->aLevel[iLvl].nSeg; iSeg++){
           pLvl->aSeg[iSegOut] = pStruct->aLevel[iLvl].aSeg[iSeg];
           iSegOut++;
@@ -178044,230 +180017,32 @@ static int sqlite3Fts5IndexMerge(Fts5Index *p, int nMerge){
   return fts5IndexReturn(p);
 }
 
-static void fts5PoslistCallback(
-  Fts5Index *p, 
-  void *pContext, 
-  const u8 *pChunk, int nChunk
-){
-  assert_nc( nChunk>=0 );
-  if( nChunk>0 ){
-    fts5BufferSafeAppendBlob((Fts5Buffer*)pContext, pChunk, nChunk);
-  }
-}
-
-typedef struct PoslistCallbackCtx PoslistCallbackCtx;
-struct PoslistCallbackCtx {
-  Fts5Buffer *pBuf;               /* Append to this buffer */
-  Fts5Colset *pColset;            /* Restrict matches to this column */
-  int eState;                     /* See above */
-};
-
-/*
-** TODO: Make this more efficient!
-*/
-static int fts5IndexColsetTest(Fts5Colset *pColset, int iCol){
-  int i;
-  for(i=0; i<pColset->nCol; i++){
-    if( pColset->aiCol[i]==iCol ) return 1;
-  }
-  return 0;
-}
-
-static void fts5PoslistFilterCallback(
-  Fts5Index *p, 
-  void *pContext, 
-  const u8 *pChunk, int nChunk
-){
-  PoslistCallbackCtx *pCtx = (PoslistCallbackCtx*)pContext;
-  assert_nc( nChunk>=0 );
-  if( nChunk>0 ){
-    /* Search through to find the first varint with value 1. This is the
-    ** start of the next columns hits. */
-    int i = 0;
-    int iStart = 0;
-
-    if( pCtx->eState==2 ){
-      int iCol;
-      fts5FastGetVarint32(pChunk, i, iCol);
-      if( fts5IndexColsetTest(pCtx->pColset, iCol) ){
-        pCtx->eState = 1;
-        fts5BufferSafeAppendVarint(pCtx->pBuf, 1);
-      }else{
-        pCtx->eState = 0;
-      }
-    }
-
-    do {
-      while( i<nChunk && pChunk[i]!=0x01 ){
-        while( pChunk[i] & 0x80 ) i++;
-        i++;
-      }
-      if( pCtx->eState ){
-        fts5BufferSafeAppendBlob(pCtx->pBuf, &pChunk[iStart], i-iStart);
-      }
-      if( i<nChunk ){
-        int iCol;
-        iStart = i;
-        i++;
-        if( i>=nChunk ){
-          pCtx->eState = 2;
-        }else{
-          fts5FastGetVarint32(pChunk, i, iCol);
-          pCtx->eState = fts5IndexColsetTest(pCtx->pColset, iCol);
-          if( pCtx->eState ){
-            fts5BufferSafeAppendBlob(pCtx->pBuf, &pChunk[iStart], i-iStart);
-            iStart = i;
-          }
-        }
-      }
-    }while( i<nChunk );
-  }
-}
-
-/*
-** Iterator pIter currently points to a valid entry (not EOF). This
-** function appends the position list data for the current entry to
-** buffer pBuf. It does not make a copy of the position-list size
-** field.
-*/
-static void fts5SegiterPoslist(
-  Fts5Index *p,
-  Fts5SegIter *pSeg,
-  Fts5Colset *pColset,
-  Fts5Buffer *pBuf
-){
-  if( 0==fts5BufferGrow(&p->rc, pBuf, pSeg->nPos) ){
-    if( pColset==0 ){
-      fts5ChunkIterate(p, pSeg, (void*)pBuf, fts5PoslistCallback);
-    }else{
-      PoslistCallbackCtx sCtx;
-      sCtx.pBuf = pBuf;
-      sCtx.pColset = pColset;
-      sCtx.eState = fts5IndexColsetTest(pColset, 0);
-      assert( sCtx.eState==0 || sCtx.eState==1 );
-      fts5ChunkIterate(p, pSeg, (void*)&sCtx, fts5PoslistFilterCallback);
-    }
-  }
-}
-
-/*
-** IN/OUT parameter (*pa) points to a position list n bytes in size. If
-** the position list contains entries for column iCol, then (*pa) is set
-** to point to the sub-position-list for that column and the number of
-** bytes in it returned. Or, if the argument position list does not
-** contain any entries for column iCol, return 0.
-*/
-static int fts5IndexExtractCol(
-  const u8 **pa,                  /* IN/OUT: Pointer to poslist */
-  int n,                          /* IN: Size of poslist in bytes */
-  int iCol                        /* Column to extract from poslist */
-){
-  int iCurrent = 0;               /* Anything before the first 0x01 is col 0 */
-  const u8 *p = *pa;
-  const u8 *pEnd = &p[n];         /* One byte past end of position list */
-  u8 prev = 0;
-
-  while( iCol>iCurrent ){
-    /* Advance pointer p until it points to pEnd or an 0x01 byte that is
-    ** not part of a varint */
-    while( (prev & 0x80) || *p!=0x01 ){
-      prev = *p++;
-      if( p==pEnd ) return 0;
-    }
-    *pa = p++;
-    p += fts5GetVarint32(p, iCurrent);
-  }
-  if( iCol!=iCurrent ) return 0;
-
-  /* Advance pointer p until it points to pEnd or an 0x01 byte that is
-  ** not part of a varint */
-  assert( (prev & 0x80)==0 );
-  while( p<pEnd && ((prev & 0x80) || *p!=0x01) ){
-    prev = *p++;
-  }
-  return p - (*pa);
-}
-
-
-/*
-** Iterator pMulti currently points to a valid entry (not EOF). This
-** function appends the following to buffer pBuf:
-**
-**   * The varint iDelta, and
-**   * the position list that currently points to, including the size field.
-**
-** If argument pColset is NULL, then the position list is filtered according
-** to pColset before being appended to the buffer. If this means there are
-** no entries in the position list, nothing is appended to the buffer (not
-** even iDelta).
-**
-** If an error occurs, an error code is left in p->rc. 
-*/
-static int fts5AppendPoslist(
+static void fts5AppendRowid(
   Fts5Index *p,
   i64 iDelta,
-  Fts5IndexIter *pMulti,
-  Fts5Colset *pColset,
+  Fts5Iter *pUnused,
   Fts5Buffer *pBuf
 ){
-  if( p->rc==SQLITE_OK ){
-    Fts5SegIter *pSeg = &pMulti->aSeg[ pMulti->aFirst[1].iFirst ];
-    assert( fts5MultiIterEof(p, pMulti)==0 );
-    assert( pSeg->nPos>0 );
-    if( 0==fts5BufferGrow(&p->rc, pBuf, pSeg->nPos+9+9) ){
-
-      if( pSeg->iLeafOffset+pSeg->nPos<=pSeg->pLeaf->szLeaf 
-       && (pColset==0 || pColset->nCol==1)
-      ){
-        const u8 *pPos = &pSeg->pLeaf->p[pSeg->iLeafOffset];
-        int nPos;
-        if( pColset ){
-          nPos = fts5IndexExtractCol(&pPos, pSeg->nPos, pColset->aiCol[0]);
-          if( nPos==0 ) return 1;
-        }else{
-          nPos = pSeg->nPos;
-        }
-        assert( nPos>0 );
-        fts5BufferSafeAppendVarint(pBuf, iDelta);
-        fts5BufferSafeAppendVarint(pBuf, nPos*2);
-        fts5BufferSafeAppendBlob(pBuf, pPos, nPos);
-      }else{
-        int iSv1;
-        int iSv2;
-        int iData;
-
-        /* Append iDelta */
-        iSv1 = pBuf->n;
-        fts5BufferSafeAppendVarint(pBuf, iDelta);
-
-        /* WRITEPOSLISTSIZE */
-        iSv2 = pBuf->n;
-        fts5BufferSafeAppendVarint(pBuf, pSeg->nPos*2);
-        iData = pBuf->n;
-
-        fts5SegiterPoslist(p, pSeg, pColset, pBuf);
-
-        if( pColset ){
-          int nActual = pBuf->n - iData;
-          if( nActual!=pSeg->nPos ){
-            if( nActual==0 ){
-              pBuf->n = iSv1;
-              return 1;
-            }else{
-              int nReq = sqlite3Fts5GetVarintLen((u32)(nActual*2));
-              while( iSv2<(iData-nReq) ){ pBuf->p[iSv2++] = 0x80; }
-              sqlite3Fts5PutVarint(&pBuf->p[iSv2], nActual*2);
-            }
-          }
-        }
-      }
-
-    }
-  }
-
-  return 0;
+  UNUSED_PARAM(pUnused);
+  fts5BufferAppendVarint(&p->rc, pBuf, iDelta);
 }
 
+static void fts5AppendPoslist(
+  Fts5Index *p,
+  i64 iDelta,
+  Fts5Iter *pMulti,
+  Fts5Buffer *pBuf
+){
+  int nData = pMulti->base.nData;
+  assert( nData>0 );
+  if( p->rc==SQLITE_OK && 0==fts5BufferGrow(&p->rc, pBuf, nData+9+9) ){
+    fts5BufferSafeAppendVarint(pBuf, iDelta);
+    fts5BufferSafeAppendVarint(pBuf, nData*2);
+    fts5BufferSafeAppendBlob(pBuf, pMulti->base.pData, nData);
+  }
+}
+
+
 static void fts5DoclistIterNext(Fts5DoclistIter *pIter){
   u8 *p = pIter->aPoslist + pIter->nSize + pIter->nPoslist;
 
@@ -178328,6 +180103,69 @@ static void fts5MergeAppendDocid(
   (iLastRowid) = (iRowid);                                     \
 }
 
+/*
+** Swap the contents of buffer *p1 with that of *p2.
+*/
+static void fts5BufferSwap(Fts5Buffer *p1, Fts5Buffer *p2){
+  Fts5Buffer tmp = *p1;
+  *p1 = *p2;
+  *p2 = tmp;
+}
+
+static void fts5NextRowid(Fts5Buffer *pBuf, int *piOff, i64 *piRowid){
+  int i = *piOff;
+  if( i>=pBuf->n ){
+    *piOff = -1;
+  }else{
+    u64 iVal;
+    *piOff = i + sqlite3Fts5GetVarint(&pBuf->p[i], &iVal);
+    *piRowid += iVal;
+  }
+}
+
+/*
+** This is the equivalent of fts5MergePrefixLists() for detail=none mode.
+** In this case the buffers consist of a delta-encoded list of rowids only.
+*/
+static void fts5MergeRowidLists(
+  Fts5Index *p,                   /* FTS5 backend object */
+  Fts5Buffer *p1,                 /* First list to merge */
+  Fts5Buffer *p2                  /* Second list to merge */
+){
+  int i1 = 0;
+  int i2 = 0;
+  i64 iRowid1 = 0;
+  i64 iRowid2 = 0;
+  i64 iOut = 0;
+
+  Fts5Buffer out;
+  memset(&out, 0, sizeof(out));
+  sqlite3Fts5BufferSize(&p->rc, &out, p1->n + p2->n);
+  if( p->rc ) return;
+
+  fts5NextRowid(p1, &i1, &iRowid1);
+  fts5NextRowid(p2, &i2, &iRowid2);
+  while( i1>=0 || i2>=0 ){
+    if( i1>=0 && (i2<0 || iRowid1<iRowid2) ){
+      assert( iOut==0 || iRowid1>iOut );
+      fts5BufferSafeAppendVarint(&out, iRowid1 - iOut);
+      iOut = iRowid1;
+      fts5NextRowid(p1, &i1, &iRowid1);
+    }else{
+      assert( iOut==0 || iRowid2>iOut );
+      fts5BufferSafeAppendVarint(&out, iRowid2 - iOut);
+      iOut = iRowid2;
+      if( i1>=0 && iRowid1==iRowid2 ){
+        fts5NextRowid(p1, &i1, &iRowid1);
+      }
+      fts5NextRowid(p2, &i2, &iRowid2);
+    }
+  }
+
+  fts5BufferSwap(&out, p1);
+  fts5BufferFree(&out);
+}
+
 /*
 ** Buffers p1 and p2 contain doclists. This function merges the content
 ** of the two doclists together and sets buffer p1 to the result before
@@ -178345,28 +180183,30 @@ static void fts5MergePrefixLists(
     i64 iLastRowid = 0;
     Fts5DoclistIter i1;
     Fts5DoclistIter i2;
-    Fts5Buffer out;
-    Fts5Buffer tmp;
-    memset(&out, 0, sizeof(out));
-    memset(&tmp, 0, sizeof(tmp));
+    Fts5Buffer out = {0, 0, 0};
+    Fts5Buffer tmp = {0, 0, 0};
 
-    sqlite3Fts5BufferSize(&p->rc, &out, p1->n + p2->n);
+    if( sqlite3Fts5BufferSize(&p->rc, &out, p1->n + p2->n) ) return;
     fts5DoclistIterInit(p1, &i1);
     fts5DoclistIterInit(p2, &i2);
-    while( p->rc==SQLITE_OK && (i1.aPoslist!=0 || i2.aPoslist!=0) ){
-      if( i2.aPoslist==0 || (i1.aPoslist && i1.iRowid<i2.iRowid) ){
+
+    while( 1 ){
+      if( i1.iRowid<i2.iRowid ){
         /* Copy entry from i1 */
         fts5MergeAppendDocid(&out, iLastRowid, i1.iRowid);
         fts5BufferSafeAppendBlob(&out, i1.aPoslist, i1.nPoslist+i1.nSize);
         fts5DoclistIterNext(&i1);
+        if( i1.aPoslist==0 ) break;
       }
-      else if( i1.aPoslist==0 || i2.iRowid!=i1.iRowid ){
+      else if( i2.iRowid!=i1.iRowid ){
         /* Copy entry from i2 */
         fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid);
         fts5BufferSafeAppendBlob(&out, i2.aPoslist, i2.nPoslist+i2.nSize);
         fts5DoclistIterNext(&i2);
+        if( i2.aPoslist==0 ) break;
       }
       else{
+        /* Merge the two position lists. */ 
         i64 iPos1 = 0;
         i64 iPos2 = 0;
         int iOff1 = 0;
@@ -178374,29 +180214,53 @@ static void fts5MergePrefixLists(
         u8 *a1 = &i1.aPoslist[i1.nSize];
         u8 *a2 = &i2.aPoslist[i2.nSize];
 
+        i64 iPrev = 0;
         Fts5PoslistWriter writer;
         memset(&writer, 0, sizeof(writer));
 
-        /* Merge the two position lists. */ 
         fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid);
         fts5BufferZero(&tmp);
+        sqlite3Fts5BufferSize(&p->rc, &tmp, i1.nPoslist + i2.nPoslist);
+        if( p->rc ) break;
 
         sqlite3Fts5PoslistNext64(a1, i1.nPoslist, &iOff1, &iPos1);
         sqlite3Fts5PoslistNext64(a2, i2.nPoslist, &iOff2, &iPos2);
+        assert( iPos1>=0 && iPos2>=0 );
 
-        while( p->rc==SQLITE_OK && (iPos1>=0 || iPos2>=0) ){
-          i64 iNew;
-          if( iPos2<0 || (iPos1>=0 && iPos1<iPos2) ){
-            iNew = iPos1;
-            sqlite3Fts5PoslistNext64(a1, i1.nPoslist, &iOff1, &iPos1);
-          }else{
-            iNew = iPos2;
-            sqlite3Fts5PoslistNext64(a2, i2.nPoslist, &iOff2, &iPos2);
-            if( iPos1==iPos2 ){
-              sqlite3Fts5PoslistNext64(a1, i1.nPoslist, &iOff1,&iPos1);
+        if( iPos1<iPos2 ){
+          sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos1);
+          sqlite3Fts5PoslistNext64(a1, i1.nPoslist, &iOff1, &iPos1);
+        }else{
+          sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos2);
+          sqlite3Fts5PoslistNext64(a2, i2.nPoslist, &iOff2, &iPos2);
+        }
+
+        if( iPos1>=0 && iPos2>=0 ){
+          while( 1 ){
+            if( iPos1<iPos2 ){
+              if( iPos1!=iPrev ){
+                sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos1);
+              }
+              sqlite3Fts5PoslistNext64(a1, i1.nPoslist, &iOff1, &iPos1);
+              if( iPos1<0 ) break;
+            }else{
+              assert( iPos2!=iPrev );
+              sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos2);
+              sqlite3Fts5PoslistNext64(a2, i2.nPoslist, &iOff2, &iPos2);
+              if( iPos2<0 ) break;
             }
           }
-          p->rc = sqlite3Fts5PoslistWriterAppend(&tmp, &writer, iNew);
+        }
+
+        if( iPos1>=0 ){
+          if( iPos1!=iPrev ){
+            sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos1);
+          }
+          fts5BufferSafeAppendBlob(&tmp, &a1[iOff1], i1.nPoslist-iOff1);
+        }else{
+          assert( iPos2>=0 && iPos2!=iPrev );
+          sqlite3Fts5PoslistSafeAppend(&tmp, &iPrev, iPos2);
+          fts5BufferSafeAppendBlob(&tmp, &a2[iOff2], i2.nPoslist-iOff2);
         }
 
         /* WRITEPOSLISTSIZE */
@@ -178404,84 +180268,105 @@ static void fts5MergePrefixLists(
         fts5BufferSafeAppendBlob(&out, tmp.p, tmp.n);
         fts5DoclistIterNext(&i1);
         fts5DoclistIterNext(&i2);
+        if( i1.aPoslist==0 || i2.aPoslist==0 ) break;
       }
     }
 
+    if( i1.aPoslist ){
+      fts5MergeAppendDocid(&out, iLastRowid, i1.iRowid);
+      fts5BufferSafeAppendBlob(&out, i1.aPoslist, i1.aEof - i1.aPoslist);
+    }
+    else if( i2.aPoslist ){
+      fts5MergeAppendDocid(&out, iLastRowid, i2.iRowid);
+      fts5BufferSafeAppendBlob(&out, i2.aPoslist, i2.aEof - i2.aPoslist);
+    }
+
     fts5BufferSet(&p->rc, p1, out.n, out.p);
     fts5BufferFree(&tmp);
     fts5BufferFree(&out);
   }
 }
 
-static void fts5BufferSwap(Fts5Buffer *p1, Fts5Buffer *p2){
-  Fts5Buffer tmp = *p1;
-  *p1 = *p2;
-  *p2 = tmp;
-}
-
 static void fts5SetupPrefixIter(
   Fts5Index *p,                   /* Index to read from */
   int bDesc,                      /* True for "ORDER BY rowid DESC" */
   const u8 *pToken,               /* Buffer containing prefix to match */
   int nToken,                     /* Size of buffer pToken in bytes */
   Fts5Colset *pColset,            /* Restrict matches to these columns */
-  Fts5IndexIter **ppIter          /* OUT: New iterator */
+  Fts5Iter **ppIter          /* OUT: New iterator */
 ){
   Fts5Structure *pStruct;
   Fts5Buffer *aBuf;
   const int nBuf = 32;
 
+  void (*xMerge)(Fts5Index*, Fts5Buffer*, Fts5Buffer*);
+  void (*xAppend)(Fts5Index*, i64, Fts5Iter*, Fts5Buffer*);
+  if( p->pConfig->eDetail==FTS5_DETAIL_NONE ){
+    xMerge = fts5MergeRowidLists;
+    xAppend = fts5AppendRowid;
+  }else{
+    xMerge = fts5MergePrefixLists;
+    xAppend = fts5AppendPoslist;
+  }
+
   aBuf = (Fts5Buffer*)fts5IdxMalloc(p, sizeof(Fts5Buffer)*nBuf);
   pStruct = fts5StructureRead(p);
 
   if( aBuf && pStruct ){
-    const int flags = FTS5INDEX_QUERY_SCAN;
+    const int flags = FTS5INDEX_QUERY_SCAN 
+                    | FTS5INDEX_QUERY_SKIPEMPTY 
+                    | FTS5INDEX_QUERY_NOOUTPUT;
     int i;
     i64 iLastRowid = 0;
-    Fts5IndexIter *p1 = 0;     /* Iterator used to gather data from index */
+    Fts5Iter *p1 = 0;     /* Iterator used to gather data from index */
     Fts5Data *pData;
     Fts5Buffer doclist;
     int bNewTerm = 1;
 
     memset(&doclist, 0, sizeof(doclist));
-    for(fts5MultiIterNew(p, pStruct, 1, flags, pToken, nToken, -1, 0, &p1);
+    fts5MultiIterNew(p, pStruct, flags, pColset, pToken, nToken, -1, 0, &p1);
+    fts5IterSetOutputCb(&p->rc, p1);
+    for( /* no-op */ ;
         fts5MultiIterEof(p, p1)==0;
         fts5MultiIterNext2(p, p1, &bNewTerm)
     ){
-      i64 iRowid = fts5MultiIterRowid(p1);
-      int nTerm;
-      const u8 *pTerm = fts5MultiIterTerm(p1, &nTerm);
+      Fts5SegIter *pSeg = &p1->aSeg[ p1->aFirst[1].iFirst ];
+      int nTerm = pSeg->term.n;
+      const u8 *pTerm = pSeg->term.p;
+      p1->xSetOutputs(p1, pSeg);
+
       assert_nc( memcmp(pToken, pTerm, MIN(nToken, nTerm))<=0 );
       if( bNewTerm ){
         if( nTerm<nToken || memcmp(pToken, pTerm, nToken) ) break;
       }
 
-      if( doclist.n>0 && iRowid<=iLastRowid ){
+      if( p1->base.nData==0 ) continue;
+
+      if( p1->base.iRowid<=iLastRowid && doclist.n>0 ){
         for(i=0; p->rc==SQLITE_OK && doclist.n; i++){
           assert( i<nBuf );
           if( aBuf[i].n==0 ){
             fts5BufferSwap(&doclist, &aBuf[i]);
             fts5BufferZero(&doclist);
           }else{
-            fts5MergePrefixLists(p, &doclist, &aBuf[i]);
+            xMerge(p, &doclist, &aBuf[i]);
             fts5BufferZero(&aBuf[i]);
           }
         }
         iLastRowid = 0;
       }
 
-      if( !fts5AppendPoslist(p, iRowid-iLastRowid, p1, pColset, &doclist) ){
-        iLastRowid = iRowid;
-      }
+      xAppend(p, p1->base.iRowid-iLastRowid, p1, &doclist);
+      iLastRowid = p1->base.iRowid;
     }
 
     for(i=0; i<nBuf; i++){
       if( p->rc==SQLITE_OK ){
-        fts5MergePrefixLists(p, &doclist, &aBuf[i]);
+        xMerge(p, &doclist, &aBuf[i]);
       }
       fts5BufferFree(&aBuf[i]);
     }
-    fts5MultiIterFree(p, p1);
+    fts5MultiIterFree(p1);
 
     pData = fts5IdxMalloc(p, sizeof(Fts5Data) + doclist.n);
     if( pData ){
@@ -178507,7 +180392,7 @@ static int sqlite3Fts5IndexBeginWrite(Fts5Index *p, int bDelete, i64 iRowid){
 
   /* Allocate the hash table if it has not already been allocated */
   if( p->pHash==0 ){
-    p->rc = sqlite3Fts5HashNew(&p->pHash, &p->nPendingData);
+    p->rc = sqlite3Fts5HashNew(p->pConfig, &p->pHash, &p->nPendingData);
   }
 
   /* Flush the hash table to disk if required */
@@ -178542,7 +180427,7 @@ static int sqlite3Fts5IndexSync(Fts5Index *p, int bCommit){
 static int sqlite3Fts5IndexRollback(Fts5Index *p){
   fts5CloseReader(p);
   fts5IndexDiscardData(p);
-  assert( p->rc==SQLITE_OK );
+  /* assert( p->rc==SQLITE_OK ); */
   return SQLITE_OK;
 }
 
@@ -178628,7 +180513,11 @@ static int sqlite3Fts5IndexClose(Fts5Index *p){
 ** size. Return the number of bytes in the nChar character prefix of the
 ** buffer, or 0 if there are less than nChar characters in total.
 */
-static int fts5IndexCharlenToBytelen(const char *p, int nByte, int nChar){
+static int sqlite3Fts5IndexCharlenToBytelen(
+  const char *p, 
+  int nByte, 
+  int nChar
+){
   int n = 0;
   int i;
   for(i=0; i<nChar; i++){
@@ -178685,7 +180574,8 @@ static int sqlite3Fts5IndexWrite(
   );
 
   for(i=0; i<pConfig->nPrefix && rc==SQLITE_OK; i++){
-    int nByte = fts5IndexCharlenToBytelen(pToken, nToken, pConfig->aPrefix[i]);
+    const int nChar = pConfig->aPrefix[i];
+    int nByte = sqlite3Fts5IndexCharlenToBytelen(pToken, nToken, nChar);
     if( nByte ){
       rc = sqlite3Fts5HashWrite(p->pHash, 
           p->iWriteRowid, iCol, iPos, (char)(FTS5_MAIN_PREFIX+i+1), pToken,
@@ -178709,22 +180599,27 @@ static int sqlite3Fts5IndexQuery(
   Fts5IndexIter **ppIter          /* OUT: New iterator object */
 ){
   Fts5Config *pConfig = p->pConfig;
-  Fts5IndexIter *pRet = 0;
-  int iIdx = 0;
+  Fts5Iter *pRet = 0;
   Fts5Buffer buf = {0, 0, 0};
 
   /* If the QUERY_SCAN flag is set, all other flags must be clear. */
   assert( (flags & FTS5INDEX_QUERY_SCAN)==0 || flags==FTS5INDEX_QUERY_SCAN );
 
   if( sqlite3Fts5BufferSize(&p->rc, &buf, nToken+1)==0 ){
+    int iIdx = 0;                 /* Index to search */
     memcpy(&buf.p[1], pToken, nToken);
 
-#ifdef SQLITE_DEBUG
-    /* If the QUERY_TEST_NOIDX flag was specified, then this must be a
+    /* Figure out which index to search and set iIdx accordingly. If this
+    ** is a prefix query for which there is no prefix index, set iIdx to
+    ** greater than pConfig->nPrefix to indicate that the query will be
+    ** satisfied by scanning multiple terms in the main index.
+    **
+    ** If the QUERY_TEST_NOIDX flag was specified, then this must be a
     ** prefix-query. Instead of using a prefix-index (if one exists), 
     ** evaluate the prefix query using the main FTS index. This is used
     ** for internal sanity checking by the integrity-check in debug 
     ** mode only.  */
+#ifdef SQLITE_DEBUG
     if( pConfig->bPrefixIndex==0 || (flags & FTS5INDEX_QUERY_TEST_NOIDX) ){
       assert( flags & FTS5INDEX_QUERY_PREFIX );
       iIdx = 1+pConfig->nPrefix;
@@ -178738,24 +180633,35 @@ static int sqlite3Fts5IndexQuery(
     }
 
     if( iIdx<=pConfig->nPrefix ){
+      /* Straight index lookup */
       Fts5Structure *pStruct = fts5StructureRead(p);
       buf.p[0] = (u8)(FTS5_MAIN_PREFIX + iIdx);
       if( pStruct ){
-        fts5MultiIterNew(p, pStruct, 1, flags, buf.p, nToken+1, -1, 0, &pRet);
+        fts5MultiIterNew(p, pStruct, flags | FTS5INDEX_QUERY_SKIPEMPTY, 
+            pColset, buf.p, nToken+1, -1, 0, &pRet
+        );
         fts5StructureRelease(pStruct);
       }
     }else{
+      /* Scan multiple terms in the main index */
       int bDesc = (flags & FTS5INDEX_QUERY_DESC)!=0;
       buf.p[0] = FTS5_MAIN_PREFIX;
       fts5SetupPrefixIter(p, bDesc, buf.p, nToken+1, pColset, &pRet);
+      assert( p->rc!=SQLITE_OK || pRet->pColset==0 );
+      fts5IterSetOutputCb(&p->rc, pRet);
+      if( p->rc==SQLITE_OK ){
+        Fts5SegIter *pSeg = &pRet->aSeg[pRet->aFirst[1].iFirst];
+        if( pSeg->pLeaf ) pRet->xSetOutputs(pRet, pSeg);
+      }
     }
 
     if( p->rc ){
-      sqlite3Fts5IterClose(pRet);
+      sqlite3Fts5IterClose(&pRet->base);
       pRet = 0;
       fts5CloseReader(p);
     }
-    *ppIter = pRet;
+
+    *ppIter = &pRet->base;
     sqlite3Fts5BufferFree(&buf);
   }
   return fts5IndexReturn(p);
@@ -178764,15 +180670,11 @@ static int sqlite3Fts5IndexQuery(
 /*
 ** Return true if the iterator passed as the only argument is at EOF.
 */
-static int sqlite3Fts5IterEof(Fts5IndexIter *pIter){
-  assert( pIter->pIndex->rc==SQLITE_OK );
-  return pIter->bEof;
-}
-
 /*
 ** Move to the next matching rowid. 
 */
-static int sqlite3Fts5IterNext(Fts5IndexIter *pIter){
+static int sqlite3Fts5IterNext(Fts5IndexIter *pIndexIter){
+  Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
   assert( pIter->pIndex->rc==SQLITE_OK );
   fts5MultiIterNext(pIter->pIndex, pIter, 0, 0);
   return fts5IndexReturn(pIter->pIndex);
@@ -178781,7 +180683,8 @@ static int sqlite3Fts5IterNext(Fts5IndexIter *pIter){
 /*
 ** Move to the next matching term/rowid. Used by the fts5vocab module.
 */
-static int sqlite3Fts5IterNextScan(Fts5IndexIter *pIter){
+static int sqlite3Fts5IterNextScan(Fts5IndexIter *pIndexIter){
+  Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
   Fts5Index *p = pIter->pIndex;
 
   assert( pIter->pIndex->rc==SQLITE_OK );
@@ -178792,7 +180695,7 @@ static int sqlite3Fts5IterNextScan(Fts5IndexIter *pIter){
     if( pSeg->pLeaf && pSeg->term.p[0]!=FTS5_MAIN_PREFIX ){
       fts5DataRelease(pSeg->pLeaf);
       pSeg->pLeaf = 0;
-      pIter->bEof = 1;
+      pIter->base.bEof = 1;
     }
   }
 
@@ -178804,111 +180707,30 @@ static int sqlite3Fts5IterNextScan(Fts5IndexIter *pIter){
 ** definition of "at or after" depends on whether this iterator iterates
 ** in ascending or descending rowid order.
 */
-static int sqlite3Fts5IterNextFrom(Fts5IndexIter *pIter, i64 iMatch){
+static int sqlite3Fts5IterNextFrom(Fts5IndexIter *pIndexIter, i64 iMatch){
+  Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
   fts5MultiIterNextFrom(pIter->pIndex, pIter, iMatch);
   return fts5IndexReturn(pIter->pIndex);
 }
 
-/*
-** Return the current rowid.
-*/
-static i64 sqlite3Fts5IterRowid(Fts5IndexIter *pIter){
-  return fts5MultiIterRowid(pIter);
-}
-
 /*
 ** Return the current term.
 */
-static const char *sqlite3Fts5IterTerm(Fts5IndexIter *pIter, int *pn){
+static const char *sqlite3Fts5IterTerm(Fts5IndexIter *pIndexIter, int *pn){
   int n;
-  const char *z = (const char*)fts5MultiIterTerm(pIter, &n);
+  const char *z = (const char*)fts5MultiIterTerm((Fts5Iter*)pIndexIter, &n);
   *pn = n-1;
   return &z[1];
 }
 
-
-static int fts5IndexExtractColset (
-  Fts5Colset *pColset,            /* Colset to filter on */
-  const u8 *pPos, int nPos,       /* Position list */
-  Fts5Buffer *pBuf                /* Output buffer */
-){
-  int rc = SQLITE_OK;
-  int i;
-
-  fts5BufferZero(pBuf);
-  for(i=0; i<pColset->nCol; i++){
-    const u8 *pSub = pPos;
-    int nSub = fts5IndexExtractCol(&pSub, nPos, pColset->aiCol[i]);
-    if( nSub ){
-      fts5BufferAppendBlob(&rc, pBuf, nSub, pSub);
-    }
-  }
-  return rc;
-}
-
-
-/*
-** Return a pointer to a buffer containing a copy of the position list for
-** the current entry. Output variable *pn is set to the size of the buffer 
-** in bytes before returning.
-**
-** The returned position list does not include the "number of bytes" varint
-** field that starts the position list on disk.
-*/
-static int sqlite3Fts5IterPoslist(
-  Fts5IndexIter *pIter, 
-  Fts5Colset *pColset,            /* Column filter (or NULL) */
-  const u8 **pp,                  /* OUT: Pointer to position-list data */
-  int *pn,                        /* OUT: Size of position-list in bytes */
-  i64 *piRowid                    /* OUT: Current rowid */
-){
-  Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
-  assert( pIter->pIndex->rc==SQLITE_OK );
-  *piRowid = pSeg->iRowid;
-  if( pSeg->iLeafOffset+pSeg->nPos<=pSeg->pLeaf->szLeaf ){
-    u8 *pPos = &pSeg->pLeaf->p[pSeg->iLeafOffset];
-    if( pColset==0 || pIter->bFiltered ){
-      *pn = pSeg->nPos;
-      *pp = pPos;
-    }else if( pColset->nCol==1 ){
-      *pp = pPos;
-      *pn = fts5IndexExtractCol(pp, pSeg->nPos, pColset->aiCol[0]);
-    }else{
-      fts5BufferZero(&pIter->poslist);
-      fts5IndexExtractColset(pColset, pPos, pSeg->nPos, &pIter->poslist);
-      *pp = pIter->poslist.p;
-      *pn = pIter->poslist.n;
-    }
-  }else{
-    fts5BufferZero(&pIter->poslist);
-    fts5SegiterPoslist(pIter->pIndex, pSeg, pColset, &pIter->poslist);
-    *pp = pIter->poslist.p;
-    *pn = pIter->poslist.n;
-  }
-  return fts5IndexReturn(pIter->pIndex);
-}
-
-/*
-** This function is similar to sqlite3Fts5IterPoslist(), except that it
-** copies the position list into the buffer supplied as the second 
-** argument.
-*/
-static int sqlite3Fts5IterPoslistBuffer(Fts5IndexIter *pIter, Fts5Buffer *pBuf){
-  Fts5Index *p = pIter->pIndex;
-  Fts5SegIter *pSeg = &pIter->aSeg[ pIter->aFirst[1].iFirst ];
-  assert( p->rc==SQLITE_OK );
-  fts5BufferZero(pBuf);
-  fts5SegiterPoslist(p, pSeg, 0, pBuf);
-  return fts5IndexReturn(p);
-}
-
 /*
 ** Close an iterator opened by an earlier call to sqlite3Fts5IndexQuery().
 */
-static void sqlite3Fts5IterClose(Fts5IndexIter *pIter){
-  if( pIter ){
+static void sqlite3Fts5IterClose(Fts5IndexIter *pIndexIter){
+  if( pIndexIter ){
+    Fts5Iter *pIter = (Fts5Iter*)pIndexIter;
     Fts5Index *pIndex = pIter->pIndex;
-    fts5MultiIterFree(pIter->pIndex, pIter);
+    fts5MultiIterFree(pIter);
     fts5CloseReader(pIndex);
   }
 }
@@ -179001,7 +180823,7 @@ static int sqlite3Fts5IndexLoadConfig(Fts5Index *p){
 /*
 ** Return a simple checksum value based on the arguments.
 */
-static u64 fts5IndexEntryCksum(
+static u64 sqlite3Fts5IndexEntryCksum(
   i64 iRowid, 
   int iCol, 
   int iPos, 
@@ -179071,30 +180893,32 @@ static int fts5QueryCksum(
   int flags,                      /* Flags for Fts5IndexQuery */
   u64 *pCksum                     /* IN/OUT: Checksum value */
 ){
+  int eDetail = p->pConfig->eDetail;
   u64 cksum = *pCksum;
-  Fts5IndexIter *pIdxIter = 0;
-  int rc = sqlite3Fts5IndexQuery(p, z, n, flags, 0, &pIdxIter);
+  Fts5IndexIter *pIter = 0;
+  int rc = sqlite3Fts5IndexQuery(p, z, n, flags, 0, &pIter);
 
-  while( rc==SQLITE_OK && 0==sqlite3Fts5IterEof(pIdxIter) ){
-    i64 dummy;
-    const u8 *pPos;
-    int nPos;
-    i64 rowid = sqlite3Fts5IterRowid(pIdxIter);
-    rc = sqlite3Fts5IterPoslist(pIdxIter, 0, &pPos, &nPos, &dummy);
-    if( rc==SQLITE_OK ){
+  while( rc==SQLITE_OK && 0==sqlite3Fts5IterEof(pIter) ){
+    i64 rowid = pIter->iRowid;
+
+    if( eDetail==FTS5_DETAIL_NONE ){
+      cksum ^= sqlite3Fts5IndexEntryCksum(rowid, 0, 0, iIdx, z, n);
+    }else{
       Fts5PoslistReader sReader;
-      for(sqlite3Fts5PoslistReaderInit(pPos, nPos, &sReader);
+      for(sqlite3Fts5PoslistReaderInit(pIter->pData, pIter->nData, &sReader);
           sReader.bEof==0;
           sqlite3Fts5PoslistReaderNext(&sReader)
       ){
         int iCol = FTS5_POS2COLUMN(sReader.iPos);
         int iOff = FTS5_POS2OFFSET(sReader.iPos);
-        cksum ^= fts5IndexEntryCksum(rowid, iCol, iOff, iIdx, z, n);
+        cksum ^= sqlite3Fts5IndexEntryCksum(rowid, iCol, iOff, iIdx, z, n);
       }
-      rc = sqlite3Fts5IterNext(pIdxIter);
+    }
+    if( rc==SQLITE_OK ){
+      rc = sqlite3Fts5IterNext(pIter);
     }
   }
-  sqlite3Fts5IterClose(pIdxIter);
+  sqlite3Fts5IterClose(pIter);
 
   *pCksum = cksum;
   return rc;
@@ -179388,7 +181212,7 @@ static void fts5IndexIntegrityCheckSegment(
 /*
 ** Run internal checks to ensure that the FTS index (a) is internally 
 ** consistent and (b) contains entries for which the XOR of the checksums
-** as calculated by fts5IndexEntryCksum() is cksum.
+** as calculated by sqlite3Fts5IndexEntryCksum() is cksum.
 **
 ** Return SQLITE_CORRUPT if any of the internal checks fail, or if the
 ** checksum does not match. Return SQLITE_OK if all checks pass without
@@ -179396,9 +181220,10 @@ static void fts5IndexIntegrityCheckSegment(
 ** occurs.
 */
 static int sqlite3Fts5IndexIntegrityCheck(Fts5Index *p, u64 cksum){
+  int eDetail = p->pConfig->eDetail;
   u64 cksum2 = 0;                 /* Checksum based on contents of indexes */
   Fts5Buffer poslist = {0,0,0};   /* Buffer used to hold a poslist */
-  Fts5IndexIter *pIter;           /* Used to iterate through entire index */
+  Fts5Iter *pIter;                /* Used to iterate through entire index */
   Fts5Structure *pStruct;         /* Index structure */
 
 #ifdef SQLITE_DEBUG
@@ -179406,6 +181231,7 @@ static int sqlite3Fts5IndexIntegrityCheck(Fts5Index *p, u64 cksum){
   u64 cksum3 = 0;                 /* Checksum based on contents of indexes */
   Fts5Buffer term = {0,0,0};      /* Buffer used to hold most recent term */
 #endif
+  const int flags = FTS5INDEX_QUERY_NOOUTPUT;
   
   /* Load the FTS index structure */
   pStruct = fts5StructureRead(p);
@@ -179434,7 +181260,7 @@ static int sqlite3Fts5IndexIntegrityCheck(Fts5Index *p, u64 cksum){
   ** same term is performed. cksum3 is calculated based on the entries
   ** extracted by these queries.
   */
-  for(fts5MultiIterNew(p, pStruct, 0, 0, 0, 0, -1, 0, &pIter);
+  for(fts5MultiIterNew(p, pStruct, flags, 0, 0, 0, -1, 0, &pIter);
       fts5MultiIterEof(p, pIter)==0;
       fts5MultiIterNext(p, pIter, 0, 0)
   ){
@@ -179447,17 +181273,23 @@ static int sqlite3Fts5IndexIntegrityCheck(Fts5Index *p, u64 cksum){
     /* If this is a new term, query for it. Update cksum3 with the results. */
     fts5TestTerm(p, &term, z, n, cksum2, &cksum3);
 
-    poslist.n = 0;
-    fts5SegiterPoslist(p, &pIter->aSeg[pIter->aFirst[1].iFirst] , 0, &poslist);
-    while( 0==sqlite3Fts5PoslistNext64(poslist.p, poslist.n, &iOff, &iPos) ){
-      int iCol = FTS5_POS2COLUMN(iPos);
-      int iTokOff = FTS5_POS2OFFSET(iPos);
-      cksum2 ^= fts5IndexEntryCksum(iRowid, iCol, iTokOff, -1, z, n);
+    if( eDetail==FTS5_DETAIL_NONE ){
+      if( 0==fts5MultiIterIsEmpty(p, pIter) ){
+        cksum2 ^= sqlite3Fts5IndexEntryCksum(iRowid, 0, 0, -1, z, n);
+      }
+    }else{
+      poslist.n = 0;
+      fts5SegiterPoslist(p, &pIter->aSeg[pIter->aFirst[1].iFirst], 0, &poslist);
+      while( 0==sqlite3Fts5PoslistNext64(poslist.p, poslist.n, &iOff, &iPos) ){
+        int iCol = FTS5_POS2COLUMN(iPos);
+        int iTokOff = FTS5_POS2OFFSET(iPos);
+        cksum2 ^= sqlite3Fts5IndexEntryCksum(iRowid, iCol, iTokOff, -1, z, n);
+      }
     }
   }
   fts5TestTerm(p, &term, 0, 0, cksum2, &cksum3);
 
-  fts5MultiIterFree(p, pIter);
+  fts5MultiIterFree(pIter);
   if( p->rc==SQLITE_OK && cksum!=cksum2 ) p->rc = FTS5_CORRUPT;
 
   fts5StructureRelease(pStruct);
@@ -179468,34 +181300,6 @@ static int sqlite3Fts5IndexIntegrityCheck(Fts5Index *p, u64 cksum){
   return fts5IndexReturn(p);
 }
 
-
-/*
-** Calculate and return a checksum that is the XOR of the index entry
-** checksum of all entries that would be generated by the token specified
-** by the final 5 arguments.
-*/
-static u64 sqlite3Fts5IndexCksum(
-  Fts5Config *pConfig,            /* Configuration object */
-  i64 iRowid,                     /* Document term appears in */
-  int iCol,                       /* Column term appears in */
-  int iPos,                       /* Position term appears in */
-  const char *pTerm, int nTerm    /* Term at iPos */
-){
-  u64 ret = 0;                    /* Return value */
-  int iIdx;                       /* For iterating through indexes */
-
-  ret = fts5IndexEntryCksum(iRowid, iCol, iPos, 0, pTerm, nTerm);
-
-  for(iIdx=0; iIdx<pConfig->nPrefix; iIdx++){
-    int nByte = fts5IndexCharlenToBytelen(pTerm, nTerm, pConfig->aPrefix[iIdx]);
-    if( nByte ){
-      ret ^= fts5IndexEntryCksum(iRowid, iCol, iPos, iIdx+1, pTerm, nByte);
-    }
-  }
-
-  return ret;
-}
-
 /*************************************************************************
 **************************************************************************
 ** Below this point is the implementation of the fts5_decode() scalar
@@ -179663,6 +181467,47 @@ static int fts5DecodeDoclist(int *pRc, Fts5Buffer *pBuf, const u8 *a, int n){
   return iOff;
 }
 
+/*
+** This function is part of the fts5_decode() debugging function. It is 
+** only ever used with detail=none tables.
+**
+** Buffer (pData/nData) contains a doclist in the format used by detail=none
+** tables. This function appends a human-readable version of that list to
+** buffer pBuf.
+**
+** If *pRc is other than SQLITE_OK when this function is called, it is a
+** no-op. If an OOM or other error occurs within this function, *pRc is
+** set to an SQLite error code before returning. The final state of buffer
+** pBuf is undefined in this case.
+*/
+static void fts5DecodeRowidList(
+  int *pRc,                       /* IN/OUT: Error code */
+  Fts5Buffer *pBuf,               /* Buffer to append text to */
+  const u8 *pData, int nData      /* Data to decode list-of-rowids from */
+){
+  int i = 0;
+  i64 iRowid = 0;
+
+  while( i<nData ){
+    const char *zApp = "";
+    u64 iVal;
+    i += sqlite3Fts5GetVarint(&pData[i], &iVal);
+    iRowid += iVal;
+
+    if( i<nData && pData[i]==0x00 ){
+      i++;
+      if( i<nData && pData[i]==0x00 ){
+        i++;
+        zApp = "+";
+      }else{
+        zApp = "*";
+      }
+    }
+
+    sqlite3Fts5BufferAppendPrintf(pRc, pBuf, " %lld%s", iRowid, zApp);
+  }
+}
+
 /*
 ** The implementation of user-defined scalar function fts5_decode().
 */
@@ -179678,8 +181523,10 @@ static void fts5DecodeFunction(
   Fts5Buffer s;                   /* Build up text to return here */
   int rc = SQLITE_OK;             /* Return code */
   int nSpace = 0;
+  int eDetailNone = (sqlite3_user_data(pCtx)!=0);
 
   assert( nArg==2 );
+  UNUSED_PARAM(nArg);
   memset(&s, 0, sizeof(Fts5Buffer));
   iRowid = sqlite3_value_int64(apVal[0]);
 
@@ -179719,6 +181566,54 @@ static void fts5DecodeFunction(
     }else{
       fts5DecodeStructure(&rc, &s, a, n);
     }
+  }else if( eDetailNone ){
+    Fts5Buffer term;              /* Current term read from page */
+    int szLeaf;
+    int iPgidxOff = szLeaf = fts5GetU16(&a[2]);
+    int iTermOff;
+    int nKeep = 0;
+    int iOff;
+
+    memset(&term, 0, sizeof(Fts5Buffer));
+
+    /* Decode any entries that occur before the first term. */
+    if( szLeaf<n ){
+      iPgidxOff += fts5GetVarint32(&a[iPgidxOff], iTermOff);
+    }else{
+      iTermOff = szLeaf;
+    }
+    fts5DecodeRowidList(&rc, &s, &a[4], iTermOff-4);
+
+    iOff = iTermOff;
+    while( iOff<szLeaf ){
+      int nAppend;
+
+      /* Read the term data for the next term*/
+      iOff += fts5GetVarint32(&a[iOff], nAppend);
+      term.n = nKeep;
+      fts5BufferAppendBlob(&rc, &term, nAppend, &a[iOff]);
+      sqlite3Fts5BufferAppendPrintf(
+          &rc, &s, " term=%.*s", term.n, (const char*)term.p
+      );
+      iOff += nAppend;
+
+      /* Figure out where the doclist for this term ends */
+      if( iPgidxOff<n ){
+        int nIncr;
+        iPgidxOff += fts5GetVarint32(&a[iPgidxOff], nIncr);
+        iTermOff += nIncr;
+      }else{
+        iTermOff = szLeaf;
+      }
+
+      fts5DecodeRowidList(&rc, &s, &a[iOff], iTermOff-iOff);
+      iOff = iTermOff;
+      if( iOff<szLeaf ){
+        iOff += fts5GetVarint32(&a[iOff], nKeep);
+      }
+    }
+
+    fts5BufferFree(&term);
   }else{
     Fts5Buffer term;              /* Current term read from page */
     int szLeaf;                   /* Offset of pgidx in a[] */
@@ -179846,6 +181741,14 @@ static int sqlite3Fts5IndexInit(sqlite3 *db){
   int rc = sqlite3_create_function(
       db, "fts5_decode", 2, SQLITE_UTF8, 0, fts5DecodeFunction, 0, 0
   );
+
+  if( rc==SQLITE_OK ){
+    rc = sqlite3_create_function(
+        db, "fts5_decode_none", 2, 
+        SQLITE_UTF8, (void*)db, fts5DecodeFunction, 0, 0
+    );
+  }
+
   if( rc==SQLITE_OK ){
     rc = sqlite3_create_function(
         db, "fts5_rowid", -1, SQLITE_UTF8, 0, fts5RowidFunction, 0, 0
@@ -179854,7 +181757,6 @@ static int sqlite3Fts5IndexInit(sqlite3 *db){
   return rc;
 }
 
-
 /*
 ** 2014 Jun 09
 **
@@ -180077,12 +181979,13 @@ struct Fts5Cursor {
 /*
 ** Values for Fts5Cursor.csrflags
 */
-#define FTS5CSR_REQUIRE_CONTENT   0x01
-#define FTS5CSR_REQUIRE_DOCSIZE   0x02
-#define FTS5CSR_REQUIRE_INST      0x04
-#define FTS5CSR_EOF               0x08
+#define FTS5CSR_EOF               0x01
+#define FTS5CSR_REQUIRE_CONTENT   0x02
+#define FTS5CSR_REQUIRE_DOCSIZE   0x04
+#define FTS5CSR_REQUIRE_INST      0x08
 #define FTS5CSR_FREE_ZRANK        0x10
 #define FTS5CSR_REQUIRE_RESEEK    0x20
+#define FTS5CSR_REQUIRE_POSLIST   0x40
 
 #define BitFlagAllTest(x,y) (((x) & (y))==(y))
 #define BitFlagTest(x,y)    (((x) & (y))!=0)
@@ -180394,7 +182297,7 @@ static int fts5BestIndexMethod(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
   for(i=0; i<pInfo->nConstraint; i++){
     struct sqlite3_index_constraint *p = &pInfo->aConstraint[i];
     int j;
-    for(j=0; j<(int)ArraySize(aConstraint); j++){
+    for(j=0; j<ArraySize(aConstraint); j++){
       struct Constraint *pC = &aConstraint[j];
       if( p->iColumn==aColMap[pC->iCol] && p->op & pC->op ){
         if( p->usable ){
@@ -180441,7 +182344,7 @@ static int fts5BestIndexMethod(sqlite3_vtab *pVTab, sqlite3_index_info *pInfo){
 
   /* Assign argvIndex values to each constraint in use. */
   iNext = 1;
-  for(i=0; i<(int)ArraySize(aConstraint); i++){
+  for(i=0; i<ArraySize(aConstraint); i++){
     struct Constraint *pC = &aConstraint[i];
     if( pC->iConsIndex>=0 ){
       pInfo->aConstraintUsage[pC->iConsIndex].argvIndex = iNext++;
@@ -180496,6 +182399,7 @@ static void fts5CsrNewrow(Fts5Cursor *pCsr){
       FTS5CSR_REQUIRE_CONTENT 
     | FTS5CSR_REQUIRE_DOCSIZE 
     | FTS5CSR_REQUIRE_INST 
+    | FTS5CSR_REQUIRE_POSLIST 
   );
 }
 
@@ -180578,15 +182482,18 @@ static int fts5SorterNext(Fts5Cursor *pCsr){
     nBlob = sqlite3_column_bytes(pSorter->pStmt, 1);
     aBlob = a = sqlite3_column_blob(pSorter->pStmt, 1);
 
-    for(i=0; i<(pSorter->nIdx-1); i++){
-      int iVal;
-      a += fts5GetVarint32(a, iVal);
-      iOff += iVal;
-      pSorter->aIdx[i] = iOff;
+    /* nBlob==0 in detail=none mode. */
+    if( nBlob>0 ){
+      for(i=0; i<(pSorter->nIdx-1); i++){
+        int iVal;
+        a += fts5GetVarint32(a, iVal);
+        iOff += iVal;
+        pSorter->aIdx[i] = iOff;
+      }
+      pSorter->aIdx[i] = &aBlob[nBlob] - a;
+      pSorter->aPoslist = a;
     }
-    pSorter->aIdx[i] = &aBlob[nBlob] - a;
 
-    pSorter->aPoslist = a;
     fts5CsrNewrow(pCsr);
   }
 
@@ -180630,7 +182537,7 @@ static int fts5CursorReseek(Fts5Cursor *pCsr, int *pbSkip){
     i64 iRowid = sqlite3Fts5ExprRowid(pCsr->pExpr);
 
     rc = sqlite3Fts5ExprFirst(pCsr->pExpr, pTab->pIndex, iRowid, bDesc);
-    if( rc==SQLITE_OK && iRowid!=sqlite3Fts5ExprRowid(pCsr->pExpr) ){
+    if( rc==SQLITE_OK &&  iRowid!=sqlite3Fts5ExprRowid(pCsr->pExpr) ){
       *pbSkip = 1;
     }
 
@@ -180638,6 +182545,7 @@ static int fts5CursorReseek(Fts5Cursor *pCsr, int *pbSkip){
     fts5CsrNewrow(pCsr);
     if( sqlite3Fts5ExprEof(pCsr->pExpr) ){
       CsrFlagSet(pCsr, FTS5CSR_EOF);
+      *pbSkip = 1;
     }
   }
   return rc;
@@ -180654,24 +182562,24 @@ static int fts5CursorReseek(Fts5Cursor *pCsr, int *pbSkip){
 */
 static int fts5NextMethod(sqlite3_vtab_cursor *pCursor){
   Fts5Cursor *pCsr = (Fts5Cursor*)pCursor;
-  int rc = SQLITE_OK;
+  int rc;
 
   assert( (pCsr->ePlan<3)==
           (pCsr->ePlan==FTS5_PLAN_MATCH || pCsr->ePlan==FTS5_PLAN_SOURCE) 
   );
+  assert( !CsrFlagTest(pCsr, FTS5CSR_EOF) );
 
   if( pCsr->ePlan<3 ){
     int bSkip = 0;
     if( (rc = fts5CursorReseek(pCsr, &bSkip)) || bSkip ) return rc;
     rc = sqlite3Fts5ExprNext(pCsr->pExpr, pCsr->iLastRowid);
-    if( sqlite3Fts5ExprEof(pCsr->pExpr) ){
-      CsrFlagSet(pCsr, FTS5CSR_EOF);
-    }
+    CsrFlagSet(pCsr, sqlite3Fts5ExprEof(pCsr->pExpr));
     fts5CsrNewrow(pCsr);
   }else{
     switch( pCsr->ePlan ){
       case FTS5_PLAN_SPECIAL: {
         CsrFlagSet(pCsr, FTS5CSR_EOF);
+        rc = SQLITE_OK;
         break;
       }
   
@@ -180696,33 +182604,32 @@ static int fts5NextMethod(sqlite3_vtab_cursor *pCursor){
 }
 
 
-static sqlite3_stmt *fts5PrepareStatement(
-  int *pRc,
+static int fts5PrepareStatement(
+  sqlite3_stmt **ppStmt,
   Fts5Config *pConfig, 
   const char *zFmt,
   ...
 ){
   sqlite3_stmt *pRet = 0;
+  int rc;
+  char *zSql;
   va_list ap;
-  va_start(ap, zFmt);
 
-  if( *pRc==SQLITE_OK ){
-    int rc;
-    char *zSql = sqlite3_vmprintf(zFmt, ap);
-    if( zSql==0 ){
-      rc = SQLITE_NOMEM; 
-    }else{
-      rc = sqlite3_prepare_v2(pConfig->db, zSql, -1, &pRet, 0);
-      if( rc!=SQLITE_OK ){
-        *pConfig->pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(pConfig->db));
-      }
-      sqlite3_free(zSql);
+  va_start(ap, zFmt);
+  zSql = sqlite3_vmprintf(zFmt, ap);
+  if( zSql==0 ){
+    rc = SQLITE_NOMEM; 
+  }else{
+    rc = sqlite3_prepare_v2(pConfig->db, zSql, -1, &pRet, 0);
+    if( rc!=SQLITE_OK ){
+      *pConfig->pzErrmsg = sqlite3_mprintf("%s", sqlite3_errmsg(pConfig->db));
     }
-    *pRc = rc;
+    sqlite3_free(zSql);
   }
 
   va_end(ap);
-  return pRet;
+  *ppStmt = pRet;
+  return rc;
 } 
 
 static int fts5CursorFirstSorted(Fts5Table *pTab, Fts5Cursor *pCsr, int bDesc){
@@ -180730,7 +182637,7 @@ static int fts5CursorFirstSorted(Fts5Table *pTab, Fts5Cursor *pCsr, int bDesc){
   Fts5Sorter *pSorter;
   int nPhrase;
   int nByte;
-  int rc = SQLITE_OK;
+  int rc;
   const char *zRank = pCsr->zRank;
   const char *zRankArgs = pCsr->zRankArgs;
   
@@ -180748,7 +182655,7 @@ static int fts5CursorFirstSorted(Fts5Table *pTab, Fts5Cursor *pCsr, int bDesc){
   ** table, saving it creates a circular reference.
   **
   ** If SQLite a built-in statement cache, this wouldn't be a problem. */
-  pSorter->pStmt = fts5PrepareStatement(&rc, pConfig,
+  rc = fts5PrepareStatement(&pSorter->pStmt, pConfig,
       "SELECT rowid, rank FROM %Q.%Q ORDER BY %s(%s%s%s) %s",
       pConfig->zDb, pConfig->zName, zRank, pConfig->zName,
       (zRankArgs ? ", " : ""),
@@ -180948,7 +182855,7 @@ static i64 fts5GetRowidLimit(sqlite3_value *pVal, i64 iDefault){
 static int fts5FilterMethod(
   sqlite3_vtab_cursor *pCursor,   /* The cursor used for this query */
   int idxNum,                     /* Strategy index */
-  const char *idxStr,             /* Unused */
+  const char *zUnused,            /* Unused */
   int nVal,                       /* Number of elements in apVal */
   sqlite3_value **apVal           /* Arguments for the indexing scheme */
 ){
@@ -180966,6 +182873,9 @@ static int fts5FilterMethod(
   sqlite3_value *pRowidGe = 0;    /* rowid >= ? expression (or NULL) */
   char **pzErrmsg = pConfig->pzErrmsg;
 
+  UNUSED_PARAM(zUnused);
+  UNUSED_PARAM(nVal);
+
   if( pCsr->ePlan ){
     fts5FreeCursorComponents(pCsr);
     memset(&pCsr->ePlan, 0, sizeof(Fts5Cursor) - ((u8*)&pCsr->ePlan-(u8*)pCsr));
@@ -181024,6 +182934,7 @@ static int fts5FilterMethod(
     pCsr->ePlan = FTS5_PLAN_SOURCE;
     pCsr->pExpr = pTab->pSortCsr->pExpr;
     rc = fts5CursorFirst(pTab, pCsr, bDesc);
+    sqlite3Fts5ExprClearEof(pCsr->pExpr);
   }else if( pMatch ){
     const char *zExpr = (const char*)sqlite3_value_text(apVal[0]);
     if( zExpr==0 ) zExpr = "";
@@ -181249,14 +183160,13 @@ static int fts5SpecialInsert(
 
 static int fts5SpecialDelete(
   Fts5Table *pTab, 
-  sqlite3_value **apVal, 
-  sqlite3_int64 *piRowid
+  sqlite3_value **apVal
 ){
   int rc = SQLITE_OK;
   int eType1 = sqlite3_value_type(apVal[1]);
   if( eType1==SQLITE_INTEGER ){
     sqlite3_int64 iDel = sqlite3_value_int64(apVal[1]);
-    rc = sqlite3Fts5StorageSpecialDelete(pTab->pStorage, iDel, &apVal[2]);
+    rc = sqlite3Fts5StorageDelete(pTab->pStorage, iDel, &apVal[2]);
   }
   return rc;
 }
@@ -181326,7 +183236,7 @@ static int fts5UpdateMethod(
     if( pConfig->eContent!=FTS5_CONTENT_NORMAL 
       && 0==sqlite3_stricmp("delete", z) 
     ){
-      rc = fts5SpecialDelete(pTab, apVal, pRowid);
+      rc = fts5SpecialDelete(pTab, apVal);
     }else{
       rc = fts5SpecialInsert(pTab, z, apVal[2 + pConfig->nCol + 1]);
     }
@@ -181363,7 +183273,7 @@ static int fts5UpdateMethod(
     /* Case 1: DELETE */
     else if( nArg==1 ){
       i64 iDel = sqlite3_value_int64(apVal[0]);  /* Rowid to delete */
-      rc = sqlite3Fts5StorageDelete(pTab->pStorage, iDel);
+      rc = sqlite3Fts5StorageDelete(pTab->pStorage, iDel, 0);
     }
 
     /* Case 2: INSERT */
@@ -181373,7 +183283,7 @@ static int fts5UpdateMethod(
        && sqlite3_value_type(apVal[1])==SQLITE_INTEGER 
       ){
         i64 iNew = sqlite3_value_int64(apVal[1]);  /* Rowid to delete */
-        rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew);
+        rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew, 0);
       }
       fts5StorageInsert(&rc, pTab, apVal, pRowid);
     }
@@ -181384,22 +183294,22 @@ static int fts5UpdateMethod(
       i64 iNew = sqlite3_value_int64(apVal[1]);  /* New rowid */
       if( iOld!=iNew ){
         if( eConflict==SQLITE_REPLACE ){
-          rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld);
+          rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0);
           if( rc==SQLITE_OK ){
-            rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew);
+            rc = sqlite3Fts5StorageDelete(pTab->pStorage, iNew, 0);
           }
           fts5StorageInsert(&rc, pTab, apVal, pRowid);
         }else{
           rc = sqlite3Fts5StorageContentInsert(pTab->pStorage, apVal, pRowid);
           if( rc==SQLITE_OK ){
-            rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld);
+            rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0);
           }
           if( rc==SQLITE_OK ){
             rc = sqlite3Fts5StorageIndexInsert(pTab->pStorage, apVal, *pRowid);
           }
         }
       }else{
-        rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld);
+        rc = sqlite3Fts5StorageDelete(pTab->pStorage, iOld, 0);
         fts5StorageInsert(&rc, pTab, apVal, pRowid);
       }
     }
@@ -181427,6 +183337,7 @@ static int fts5SyncMethod(sqlite3_vtab *pVtab){
 ** Implementation of xBegin() method. 
 */
 static int fts5BeginMethod(sqlite3_vtab *pVtab){
+  UNUSED_PARAM(pVtab);  /* Call below is a no-op for NDEBUG builds */
   fts5CheckTransactionState((Fts5Table*)pVtab, FTS5_BEGIN, 0);
   return SQLITE_OK;
 }
@@ -181437,6 +183348,7 @@ static int fts5BeginMethod(sqlite3_vtab *pVtab){
 ** by fts5SyncMethod().
 */
 static int fts5CommitMethod(sqlite3_vtab *pVtab){
+  UNUSED_PARAM(pVtab);  /* Call below is a no-op for NDEBUG builds */
   fts5CheckTransactionState((Fts5Table*)pVtab, FTS5_COMMIT, 0);
   return SQLITE_OK;
 }
@@ -181453,6 +183365,8 @@ static int fts5RollbackMethod(sqlite3_vtab *pVtab){
   return rc;
 }
 
+static int fts5CsrPoslist(Fts5Cursor*, int, const u8**, int*);
+
 static void *fts5ApiUserData(Fts5Context *pCtx){
   Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
   return pCsr->pAux->pUserData;
@@ -181502,17 +183416,72 @@ static int fts5ApiPhraseSize(Fts5Context *pCtx, int iPhrase){
   return sqlite3Fts5ExprPhraseSize(pCsr->pExpr, iPhrase);
 }
 
-static int fts5CsrPoslist(Fts5Cursor *pCsr, int iPhrase, const u8 **pa){
-  int n;
-  if( pCsr->pSorter ){
+static int fts5ApiColumnText(
+  Fts5Context *pCtx, 
+  int iCol, 
+  const char **pz, 
+  int *pn
+){
+  int rc = SQLITE_OK;
+  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
+  if( fts5IsContentless((Fts5Table*)(pCsr->base.pVtab)) ){
+    *pz = 0;
+    *pn = 0;
+  }else{
+    rc = fts5SeekCursor(pCsr, 0);
+    if( rc==SQLITE_OK ){
+      *pz = (const char*)sqlite3_column_text(pCsr->pStmt, iCol+1);
+      *pn = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
+    }
+  }
+  return rc;
+}
+
+static int fts5CsrPoslist(
+  Fts5Cursor *pCsr, 
+  int iPhrase, 
+  const u8 **pa,
+  int *pn
+){
+  Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
+  int rc = SQLITE_OK;
+  int bLive = (pCsr->pSorter==0);
+
+  if( CsrFlagTest(pCsr, FTS5CSR_REQUIRE_POSLIST) ){
+
+    if( pConfig->eDetail!=FTS5_DETAIL_FULL ){
+      Fts5PoslistPopulator *aPopulator;
+      int i;
+      aPopulator = sqlite3Fts5ExprClearPoslists(pCsr->pExpr, bLive);
+      if( aPopulator==0 ) rc = SQLITE_NOMEM;
+      for(i=0; i<pConfig->nCol && rc==SQLITE_OK; i++){
+        int n; const char *z;
+        rc = fts5ApiColumnText((Fts5Context*)pCsr, i, &z, &n);
+        if( rc==SQLITE_OK ){
+          rc = sqlite3Fts5ExprPopulatePoslists(
+              pConfig, pCsr->pExpr, aPopulator, i, z, n
+          );
+        }
+      }
+      sqlite3_free(aPopulator);
+
+      if( pCsr->pSorter ){
+        sqlite3Fts5ExprCheckPoslists(pCsr->pExpr, pCsr->pSorter->iRowid);
+      }
+    }
+    CsrFlagClear(pCsr, FTS5CSR_REQUIRE_POSLIST);
+  }
+
+  if( pCsr->pSorter && pConfig->eDetail==FTS5_DETAIL_FULL ){
     Fts5Sorter *pSorter = pCsr->pSorter;
     int i1 = (iPhrase==0 ? 0 : pSorter->aIdx[iPhrase-1]);
-    n = pSorter->aIdx[iPhrase] - i1;
+    *pn = pSorter->aIdx[iPhrase] - i1;
     *pa = &pSorter->aPoslist[i1];
   }else{
-    n = sqlite3Fts5ExprPoslist(pCsr->pExpr, iPhrase, pa);
+    *pn = sqlite3Fts5ExprPoslist(pCsr->pExpr, iPhrase, pa);
   }
-  return n;
+
+  return rc;
 }
 
 /*
@@ -181537,43 +183506,48 @@ static int fts5CacheInstArray(Fts5Cursor *pCsr){
     int i;
 
     /* Initialize all iterators */
-    for(i=0; i<nIter; i++){
+    for(i=0; i<nIter && rc==SQLITE_OK; i++){
       const u8 *a;
-      int n = fts5CsrPoslist(pCsr, i, &a);
-      sqlite3Fts5PoslistReaderInit(a, n, &aIter[i]);
+      int n; 
+      rc = fts5CsrPoslist(pCsr, i, &a, &n);
+      if( rc==SQLITE_OK ){
+        sqlite3Fts5PoslistReaderInit(a, n, &aIter[i]);
+      }
     }
 
-    while( 1 ){
-      int *aInst;
-      int iBest = -1;
-      for(i=0; i<nIter; i++){
-        if( (aIter[i].bEof==0) 
-         && (iBest<0 || aIter[i].iPos<aIter[iBest].iPos) 
-        ){
-          iBest = i;
+    if( rc==SQLITE_OK ){
+      while( 1 ){
+        int *aInst;
+        int iBest = -1;
+        for(i=0; i<nIter; i++){
+          if( (aIter[i].bEof==0) 
+              && (iBest<0 || aIter[i].iPos<aIter[iBest].iPos) 
+            ){
+            iBest = i;
+          }
         }
-      }
-      if( iBest<0 ) break;
+        if( iBest<0 ) break;
 
-      nInst++;
-      if( nInst>=pCsr->nInstAlloc ){
-        pCsr->nInstAlloc = pCsr->nInstAlloc ? pCsr->nInstAlloc*2 : 32;
-        aInst = (int*)sqlite3_realloc(
-            pCsr->aInst, pCsr->nInstAlloc*sizeof(int)*3
-        );
-        if( aInst ){
-          pCsr->aInst = aInst;
-        }else{
-          rc = SQLITE_NOMEM;
-          break;
+        nInst++;
+        if( nInst>=pCsr->nInstAlloc ){
+          pCsr->nInstAlloc = pCsr->nInstAlloc ? pCsr->nInstAlloc*2 : 32;
+          aInst = (int*)sqlite3_realloc(
+              pCsr->aInst, pCsr->nInstAlloc*sizeof(int)*3
+              );
+          if( aInst ){
+            pCsr->aInst = aInst;
+          }else{
+            rc = SQLITE_NOMEM;
+            break;
+          }
         }
-      }
 
-      aInst = &pCsr->aInst[3 * (nInst-1)];
-      aInst[0] = iBest;
-      aInst[1] = FTS5_POS2COLUMN(aIter[iBest].iPos);
-      aInst[2] = FTS5_POS2OFFSET(aIter[iBest].iPos);
-      sqlite3Fts5PoslistReaderNext(&aIter[iBest]);
+        aInst = &pCsr->aInst[3 * (nInst-1)];
+        aInst[0] = iBest;
+        aInst[1] = FTS5_POS2COLUMN(aIter[iBest].iPos);
+        aInst[2] = FTS5_POS2OFFSET(aIter[iBest].iPos);
+        sqlite3Fts5PoslistReaderNext(&aIter[iBest]);
+      }
     }
 
     pCsr->nInstCount = nInst;
@@ -181606,6 +183580,12 @@ static int fts5ApiInst(
   ){
     if( iIdx<0 || iIdx>=pCsr->nInstCount ){
       rc = SQLITE_RANGE;
+#if 0
+    }else if( fts5IsOffsetless((Fts5Table*)pCsr->base.pVtab) ){
+      *piPhrase = pCsr->aInst[iIdx*3];
+      *piCol = pCsr->aInst[iIdx*3 + 2];
+      *piOff = -1;
+#endif
     }else{
       *piPhrase = pCsr->aInst[iIdx*3];
       *piCol = pCsr->aInst[iIdx*3 + 1];
@@ -181619,36 +183599,17 @@ static sqlite3_int64 fts5ApiRowid(Fts5Context *pCtx){
   return fts5CursorRowid((Fts5Cursor*)pCtx);
 }
 
-static int fts5ApiColumnText(
-  Fts5Context *pCtx, 
-  int iCol, 
-  const char **pz, 
-  int *pn
-){
-  int rc = SQLITE_OK;
-  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  if( fts5IsContentless((Fts5Table*)(pCsr->base.pVtab)) ){
-    *pz = 0;
-    *pn = 0;
-  }else{
-    rc = fts5SeekCursor(pCsr, 0);
-    if( rc==SQLITE_OK ){
-      *pz = (const char*)sqlite3_column_text(pCsr->pStmt, iCol+1);
-      *pn = sqlite3_column_bytes(pCsr->pStmt, iCol+1);
-    }
-  }
-  return rc;
-}
-
 static int fts5ColumnSizeCb(
   void *pContext,                 /* Pointer to int */
   int tflags,
-  const char *pToken,             /* Buffer containing token */
-  int nToken,                     /* Size of token in bytes */
-  int iStart,                     /* Start offset of token */
-  int iEnd                        /* End offset of token */
+  const char *pUnused,            /* Buffer containing token */
+  int nUnused,                    /* Size of token in bytes */
+  int iUnused1,                   /* Start offset of token */
+  int iUnused2                    /* End offset of token */
 ){
   int *pCnt = (int*)pContext;
+  UNUSED_PARAM2(pUnused, nUnused);
+  UNUSED_PARAM2(iUnused1, iUnused2);
   if( (tflags & FTS5_TOKEN_COLOCATED)==0 ){
     (*pCnt)++;
   }
@@ -181764,10 +183725,11 @@ static void *fts5ApiGetAuxdata(Fts5Context *pCtx, int bClear){
 }
 
 static void fts5ApiPhraseNext(
-  Fts5Context *pCtx, 
+  Fts5Context *pUnused, 
   Fts5PhraseIter *pIter, 
   int *piCol, int *piOff
 ){
+  UNUSED_PARAM(pUnused);
   if( pIter->a>=pIter->b ){
     *piCol = -1;
     *piOff = -1;
@@ -181784,20 +183746,98 @@ static void fts5ApiPhraseNext(
   }
 }
 
-static void fts5ApiPhraseFirst(
+static int fts5ApiPhraseFirst(
   Fts5Context *pCtx, 
   int iPhrase, 
   Fts5PhraseIter *pIter, 
   int *piCol, int *piOff
 ){
   Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
-  int n = fts5CsrPoslist(pCsr, iPhrase, &pIter->a);
-  pIter->b = &pIter->a[n];
-  *piCol = 0;
-  *piOff = 0;
-  fts5ApiPhraseNext(pCtx, pIter, piCol, piOff);
+  int n;
+  int rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
+  if( rc==SQLITE_OK ){
+    pIter->b = &pIter->a[n];
+    *piCol = 0;
+    *piOff = 0;
+    fts5ApiPhraseNext(pCtx, pIter, piCol, piOff);
+  }
+  return rc;
 }
 
+static void fts5ApiPhraseNextColumn(
+  Fts5Context *pCtx, 
+  Fts5PhraseIter *pIter, 
+  int *piCol
+){
+  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
+  Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
+
+  if( pConfig->eDetail==FTS5_DETAIL_COLUMNS ){
+    if( pIter->a>=pIter->b ){
+      *piCol = -1;
+    }else{
+      int iIncr;
+      pIter->a += fts5GetVarint32(&pIter->a[0], iIncr);
+      *piCol += (iIncr-2);
+    }
+  }else{
+    while( 1 ){
+      int dummy;
+      if( pIter->a>=pIter->b ){
+        *piCol = -1;
+        return;
+      }
+      if( pIter->a[0]==0x01 ) break;
+      pIter->a += fts5GetVarint32(pIter->a, dummy);
+    }
+    pIter->a += 1 + fts5GetVarint32(&pIter->a[1], *piCol);
+  }
+}
+
+static int fts5ApiPhraseFirstColumn(
+  Fts5Context *pCtx, 
+  int iPhrase, 
+  Fts5PhraseIter *pIter, 
+  int *piCol
+){
+  int rc = SQLITE_OK;
+  Fts5Cursor *pCsr = (Fts5Cursor*)pCtx;
+  Fts5Config *pConfig = ((Fts5Table*)(pCsr->base.pVtab))->pConfig;
+
+  if( pConfig->eDetail==FTS5_DETAIL_COLUMNS ){
+    Fts5Sorter *pSorter = pCsr->pSorter;
+    int n;
+    if( pSorter ){
+      int i1 = (iPhrase==0 ? 0 : pSorter->aIdx[iPhrase-1]);
+      n = pSorter->aIdx[iPhrase] - i1;
+      pIter->a = &pSorter->aPoslist[i1];
+    }else{
+      rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, iPhrase, &pIter->a, &n);
+    }
+    if( rc==SQLITE_OK ){
+      pIter->b = &pIter->a[n];
+      *piCol = 0;
+      fts5ApiPhraseNextColumn(pCtx, pIter, piCol);
+    }
+  }else{
+    int n;
+    rc = fts5CsrPoslist(pCsr, iPhrase, &pIter->a, &n);
+    if( rc==SQLITE_OK ){
+      pIter->b = &pIter->a[n];
+      if( n<=0 ){
+        *piCol = -1;
+      }else if( pIter->a[0]==0x01 ){
+        pIter->a += 1 + fts5GetVarint32(&pIter->a[1], *piCol);
+      }else{
+        *piCol = 0;
+      }
+    }
+  }
+
+  return rc;
+}
+
+
 static int fts5ApiQueryPhrase(Fts5Context*, int, void*, 
     int(*)(const Fts5ExtensionApi*, Fts5Context*, void*)
 );
@@ -181821,9 +183861,10 @@ static const Fts5ExtensionApi sFts5Api = {
   fts5ApiGetAuxdata,
   fts5ApiPhraseFirst,
   fts5ApiPhraseNext,
+  fts5ApiPhraseFirstColumn,
+  fts5ApiPhraseNextColumn,
 };
 
-
 /*
 ** Implementation of API function xQueryPhrase().
 */
@@ -181840,12 +183881,11 @@ static int fts5ApiQueryPhrase(
 
   rc = fts5OpenMethod(pCsr->base.pVtab, (sqlite3_vtab_cursor**)&pNew);
   if( rc==SQLITE_OK ){
-    Fts5Config *pConf = pTab->pConfig;
     pNew->ePlan = FTS5_PLAN_MATCH;
     pNew->iFirstRowid = SMALLEST_INT64;
     pNew->iLastRowid = LARGEST_INT64;
     pNew->base.pVtab = (sqlite3_vtab*)pTab;
-    rc = sqlite3Fts5ExprClonePhrase(pConf, pCsr->pExpr, iPhrase, &pNew->pExpr);
+    rc = sqlite3Fts5ExprClonePhrase(pCsr->pExpr, iPhrase, &pNew->pExpr);
   }
 
   if( rc==SQLITE_OK ){
@@ -181955,20 +183995,46 @@ static int fts5PoslistBlob(sqlite3_context *pCtx, Fts5Cursor *pCsr){
   Fts5Buffer val;
 
   memset(&val, 0, sizeof(Fts5Buffer));
+  switch( ((Fts5Table*)(pCsr->base.pVtab))->pConfig->eDetail ){
+    case FTS5_DETAIL_FULL:
 
-  /* Append the varints */
-  for(i=0; i<(nPhrase-1); i++){
-    const u8 *dummy;
-    int nByte = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &dummy);
-    sqlite3Fts5BufferAppendVarint(&rc, &val, nByte);
-  }
+      /* Append the varints */
+      for(i=0; i<(nPhrase-1); i++){
+        const u8 *dummy;
+        int nByte = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &dummy);
+        sqlite3Fts5BufferAppendVarint(&rc, &val, nByte);
+      }
 
-  /* Append the position lists */
-  for(i=0; i<nPhrase; i++){
-    const u8 *pPoslist;
-    int nPoslist;
-    nPoslist = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &pPoslist);
-    sqlite3Fts5BufferAppendBlob(&rc, &val, nPoslist, pPoslist);
+      /* Append the position lists */
+      for(i=0; i<nPhrase; i++){
+        const u8 *pPoslist;
+        int nPoslist;
+        nPoslist = sqlite3Fts5ExprPoslist(pCsr->pExpr, i, &pPoslist);
+        sqlite3Fts5BufferAppendBlob(&rc, &val, nPoslist, pPoslist);
+      }
+      break;
+
+    case FTS5_DETAIL_COLUMNS:
+
+      /* Append the varints */
+      for(i=0; rc==SQLITE_OK && i<(nPhrase-1); i++){
+        const u8 *dummy;
+        int nByte;
+        rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &dummy, &nByte);
+        sqlite3Fts5BufferAppendVarint(&rc, &val, nByte);
+      }
+
+      /* Append the position lists */
+      for(i=0; rc==SQLITE_OK && i<nPhrase; i++){
+        const u8 *pPoslist;
+        int nPoslist;
+        rc = sqlite3Fts5ExprPhraseCollist(pCsr->pExpr, i, &pPoslist, &nPoslist);
+        sqlite3Fts5BufferAppendBlob(&rc, &val, nPoslist, pPoslist);
+      }
+      break;
+
+    default:
+      break;
   }
 
   sqlite3_result_blob(pCtx, val.p, val.n, sqlite3_free);
@@ -182032,7 +184098,7 @@ static int fts5ColumnMethod(
 */
 static int fts5FindFunctionMethod(
   sqlite3_vtab *pVtab,            /* Virtual table handle */
-  int nArg,                       /* Number of SQL function arguments */
+  int nUnused,                    /* Number of SQL function arguments */
   const char *zName,              /* Name of SQL function */
   void (**pxFunc)(sqlite3_context*,int,sqlite3_value**), /* OUT: Result */
   void **ppArg                    /* OUT: User data for *pxFunc */
@@ -182040,6 +184106,7 @@ static int fts5FindFunctionMethod(
   Fts5Table *pTab = (Fts5Table*)pVtab;
   Fts5Auxiliary *pAux;
 
+  UNUSED_PARAM(nUnused);
   pAux = fts5FindAuxiliary(pTab, zName);
   if( pAux ){
     *pxFunc = fts5ApiCallback;
@@ -182069,6 +184136,7 @@ static int fts5RenameMethod(
 */
 static int fts5SavepointMethod(sqlite3_vtab *pVtab, int iSavepoint){
   Fts5Table *pTab = (Fts5Table*)pVtab;
+  UNUSED_PARAM(iSavepoint);  /* Call below is a no-op for NDEBUG builds */
   fts5CheckTransactionState(pTab, FTS5_SAVEPOINT, iSavepoint);
   fts5TripCursors(pTab);
   return sqlite3Fts5StorageSync(pTab->pStorage, 0);
@@ -182081,6 +184149,7 @@ static int fts5SavepointMethod(sqlite3_vtab *pVtab, int iSavepoint){
 */
 static int fts5ReleaseMethod(sqlite3_vtab *pVtab, int iSavepoint){
   Fts5Table *pTab = (Fts5Table*)pVtab;
+  UNUSED_PARAM(iSavepoint);  /* Call below is a no-op for NDEBUG builds */
   fts5CheckTransactionState(pTab, FTS5_RELEASE, iSavepoint);
   fts5TripCursors(pTab);
   return sqlite3Fts5StorageSync(pTab->pStorage, 0);
@@ -182093,6 +184162,7 @@ static int fts5ReleaseMethod(sqlite3_vtab *pVtab, int iSavepoint){
 */
 static int fts5RollbackToMethod(sqlite3_vtab *pVtab, int iSavepoint){
   Fts5Table *pTab = (Fts5Table*)pVtab;
+  UNUSED_PARAM(iSavepoint);  /* Call below is a no-op for NDEBUG builds */
   fts5CheckTransactionState(pTab, FTS5_ROLLBACKTO, iSavepoint);
   fts5TripCursors(pTab);
   return sqlite3Fts5StorageRollback(pTab->pStorage);
@@ -182272,10 +184342,11 @@ static void fts5ModuleDestroy(void *pCtx){
 static void fts5Fts5Func(
   sqlite3_context *pCtx,          /* Function call context */
   int nArg,                       /* Number of args */
-  sqlite3_value **apVal           /* Function arguments */
+  sqlite3_value **apUnused        /* Function arguments */
 ){
   Fts5Global *pGlobal = (Fts5Global*)sqlite3_user_data(pCtx);
   char buf[8];
+  UNUSED_PARAM2(nArg, apUnused);
   assert( nArg==0 );
   assert( sizeof(buf)>=sizeof(pGlobal) );
   memcpy(buf, (void*)&pGlobal, sizeof(pGlobal));
@@ -182288,10 +184359,11 @@ static void fts5Fts5Func(
 static void fts5SourceIdFunc(
   sqlite3_context *pCtx,          /* Function call context */
   int nArg,                       /* Number of args */
-  sqlite3_value **apVal           /* Function arguments */
+  sqlite3_value **apUnused        /* Function arguments */
 ){
   assert( nArg==0 );
-  sqlite3_result_text(pCtx, "fts5: 2016-01-20 15:27:19 17efb4209f97fb4971656086b138599a91a75ff9", -1, SQLITE_TRANSIENT);
+  UNUSED_PARAM2(nArg, apUnused);
+  sqlite3_result_text(pCtx, "fts5: 2016-03-03 16:17:53 f047920ce16971e573bc6ec9a48b118c9de2b3a7", -1, SQLITE_TRANSIENT);
 }
 
 static int fts5Init(sqlite3 *db){
@@ -182352,6 +184424,17 @@ static int fts5Init(sqlite3 *db){
       );
     }
   }
+
+  /* If SQLITE_FTS5_ENABLE_TEST_MI is defined, assume that the file
+  ** fts5_test_mi.c is compiled and linked into the executable. And call
+  ** its entry point to enable the matchinfo() demo.  */
+#ifdef SQLITE_FTS5_ENABLE_TEST_MI
+  if( rc==SQLITE_OK ){
+    extern int sqlite3Fts5TestRegisterMatchinfo(sqlite3*);
+    rc = sqlite3Fts5TestRegisterMatchinfo(db);
+  }
+#endif
+
   return rc;
 }
 
@@ -182736,7 +184819,7 @@ static int sqlite3Fts5StorageClose(Fts5Storage *p){
     int i;
 
     /* Finalize all SQL statements */
-    for(i=0; i<(int)ArraySize(p->aStmt); i++){
+    for(i=0; i<ArraySize(p->aStmt); i++){
       sqlite3_finalize(p->aStmt[i]);
     }
 
@@ -182760,11 +184843,12 @@ static int fts5StorageInsertCallback(
   int tflags,
   const char *pToken,             /* Buffer containing token */
   int nToken,                     /* Size of token in bytes */
-  int iStart,                     /* Start offset of token */
-  int iEnd                        /* End offset of token */
+  int iUnused1,                   /* Start offset of token */
+  int iUnused2                    /* End offset of token */
 ){
   Fts5InsertCtx *pCtx = (Fts5InsertCtx*)pContext;
   Fts5Index *pIdx = pCtx->pStorage->pIndex;
+  UNUSED_PARAM2(iUnused1, iUnused2);
   if( (tflags & FTS5_TOKEN_COLOCATED)==0 || pCtx->szCol==0 ){
     pCtx->szCol++;
   }
@@ -182776,39 +184860,52 @@ static int fts5StorageInsertCallback(
 ** delete-markers to the FTS index necessary to delete it. Do not actually
 ** remove the %_content row at this time though.
 */
-static int fts5StorageDeleteFromIndex(Fts5Storage *p, i64 iDel){
+static int fts5StorageDeleteFromIndex(
+  Fts5Storage *p, 
+  i64 iDel, 
+  sqlite3_value **apVal
+){
   Fts5Config *pConfig = p->pConfig;
-  sqlite3_stmt *pSeek;            /* SELECT to read row iDel from %_data */
+  sqlite3_stmt *pSeek = 0;        /* SELECT to read row iDel from %_data */
   int rc;                         /* Return code */
+  int rc2;                        /* sqlite3_reset() return code */
+  int iCol;
+  Fts5InsertCtx ctx;
 
-  rc = fts5StorageGetStmt(p, FTS5_STMT_LOOKUP, &pSeek, 0);
-  if( rc==SQLITE_OK ){
-    int rc2;
+  if( apVal==0 ){
+    rc = fts5StorageGetStmt(p, FTS5_STMT_LOOKUP, &pSeek, 0);
+    if( rc!=SQLITE_OK ) return rc;
     sqlite3_bind_int64(pSeek, 1, iDel);
-    if( sqlite3_step(pSeek)==SQLITE_ROW ){
-      int iCol;
-      Fts5InsertCtx ctx;
-      ctx.pStorage = p;
-      ctx.iCol = -1;
-      rc = sqlite3Fts5IndexBeginWrite(p->pIndex, 1, iDel);
-      for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
-        if( pConfig->abUnindexed[iCol-1] ) continue;
-        ctx.szCol = 0;
-        rc = sqlite3Fts5Tokenize(pConfig, 
-            FTS5_TOKENIZE_DOCUMENT,
-            (const char*)sqlite3_column_text(pSeek, iCol),
-            sqlite3_column_bytes(pSeek, iCol),
-            (void*)&ctx,
-            fts5StorageInsertCallback
-        );
-        p->aTotalSize[iCol-1] -= (i64)ctx.szCol;
-      }
-      p->nTotalRow--;
+    if( sqlite3_step(pSeek)!=SQLITE_ROW ){
+      return sqlite3_reset(pSeek);
     }
-    rc2 = sqlite3_reset(pSeek);
-    if( rc==SQLITE_OK ) rc = rc2;
   }
 
+  ctx.pStorage = p;
+  ctx.iCol = -1;
+  rc = sqlite3Fts5IndexBeginWrite(p->pIndex, 1, iDel);
+  for(iCol=1; rc==SQLITE_OK && iCol<=pConfig->nCol; iCol++){
+    if( pConfig->abUnindexed[iCol-1]==0 ){
+      const char *zText;
+      int nText;
+      if( pSeek ){
+        zText = (const char*)sqlite3_column_text(pSeek, iCol);
+        nText = sqlite3_column_bytes(pSeek, iCol);
+      }else{
+        zText = (const char*)sqlite3_value_text(apVal[iCol-1]);
+        nText = sqlite3_value_bytes(apVal[iCol-1]);
+      }
+      ctx.szCol = 0;
+      rc = sqlite3Fts5Tokenize(pConfig, FTS5_TOKENIZE_DOCUMENT, 
+          zText, nText, (void*)&ctx, fts5StorageInsertCallback
+      );
+      p->aTotalSize[iCol-1] -= (i64)ctx.szCol;
+    }
+  }
+  p->nTotalRow--;
+
+  rc2 = sqlite3_reset(pSeek);
+  if( rc==SQLITE_OK ) rc = rc2;
   return rc;
 }
 
@@ -182888,16 +184985,17 @@ static int fts5StorageSaveTotals(Fts5Storage *p){
 /*
 ** Remove a row from the FTS table.
 */
-static int sqlite3Fts5StorageDelete(Fts5Storage *p, i64 iDel){
+static int sqlite3Fts5StorageDelete(Fts5Storage *p, i64 iDel, sqlite3_value **apVal){
   Fts5Config *pConfig = p->pConfig;
   int rc;
   sqlite3_stmt *pDel = 0;
 
+  assert( pConfig->eContent!=FTS5_CONTENT_NORMAL || apVal==0 );
   rc = fts5StorageLoadTotals(p, 1);
 
   /* Delete the index records */
   if( rc==SQLITE_OK ){
-    rc = fts5StorageDeleteFromIndex(p, iDel);
+    rc = fts5StorageDeleteFromIndex(p, iDel, apVal);
   }
 
   /* Delete the %_docsize record */
@@ -182930,61 +185028,6 @@ static int sqlite3Fts5StorageDelete(Fts5Storage *p, i64 iDel){
   return rc;
 }
 
-static int sqlite3Fts5StorageSpecialDelete(
-  Fts5Storage *p, 
-  i64 iDel, 
-  sqlite3_value **apVal
-){
-  Fts5Config *pConfig = p->pConfig;
-  int rc;
-  sqlite3_stmt *pDel = 0;
-
-  assert( pConfig->eContent!=FTS5_CONTENT_NORMAL );
-  rc = fts5StorageLoadTotals(p, 1);
-
-  /* Delete the index records */
-  if( rc==SQLITE_OK ){
-    int iCol;
-    Fts5InsertCtx ctx;
-    ctx.pStorage = p;
-    ctx.iCol = -1;
-
-    rc = sqlite3Fts5IndexBeginWrite(p->pIndex, 1, iDel);
-    for(iCol=0; rc==SQLITE_OK && iCol<pConfig->nCol; iCol++){
-      if( pConfig->abUnindexed[iCol] ) continue;
-      ctx.szCol = 0;
-      rc = sqlite3Fts5Tokenize(pConfig, 
-        FTS5_TOKENIZE_DOCUMENT,
-        (const char*)sqlite3_value_text(apVal[iCol]),
-        sqlite3_value_bytes(apVal[iCol]),
-        (void*)&ctx,
-        fts5StorageInsertCallback
-      );
-      p->aTotalSize[iCol] -= (i64)ctx.szCol;
-    }
-    p->nTotalRow--;
-  }
-
-  /* Delete the %_docsize record */
-  if( pConfig->bColumnsize ){
-    if( rc==SQLITE_OK ){
-      rc = fts5StorageGetStmt(p, FTS5_STMT_DELETE_DOCSIZE, &pDel, 0);
-    }
-    if( rc==SQLITE_OK ){
-      sqlite3_bind_int64(pDel, 1, iDel);
-      sqlite3_step(pDel);
-      rc = sqlite3_reset(pDel);
-    }
-  }
-
-  /* Write the averages record */
-  if( rc==SQLITE_OK ){
-    rc = fts5StorageSaveTotals(p);
-  }
-
-  return rc;
-}
-
 /*
 ** Delete all entries in the FTS5 index.
 */
@@ -183223,28 +185266,75 @@ struct Fts5IntegrityCtx {
   int iCol;
   int szCol;
   u64 cksum;
+  Fts5Termset *pTermset;
   Fts5Config *pConfig;
 };
 
+
 /*
 ** Tokenization callback used by integrity check.
 */
 static int fts5StorageIntegrityCallback(
-  void *pContext,                 /* Pointer to Fts5InsertCtx object */
+  void *pContext,                 /* Pointer to Fts5IntegrityCtx object */
   int tflags,
   const char *pToken,             /* Buffer containing token */
   int nToken,                     /* Size of token in bytes */
-  int iStart,                     /* Start offset of token */
-  int iEnd                        /* End offset of token */
+  int iUnused1,                   /* Start offset of token */
+  int iUnused2                    /* End offset of token */
 ){
   Fts5IntegrityCtx *pCtx = (Fts5IntegrityCtx*)pContext;
+  Fts5Termset *pTermset = pCtx->pTermset;
+  int bPresent;
+  int ii;
+  int rc = SQLITE_OK;
+  int iPos;
+  int iCol;
+
+  UNUSED_PARAM2(iUnused1, iUnused2);
+
   if( (tflags & FTS5_TOKEN_COLOCATED)==0 || pCtx->szCol==0 ){
     pCtx->szCol++;
   }
-  pCtx->cksum ^= sqlite3Fts5IndexCksum(
-      pCtx->pConfig, pCtx->iRowid, pCtx->iCol, pCtx->szCol-1, pToken, nToken
-  );
-  return SQLITE_OK;
+
+  switch( pCtx->pConfig->eDetail ){
+    case FTS5_DETAIL_FULL:
+      iPos = pCtx->szCol-1;
+      iCol = pCtx->iCol;
+      break;
+
+    case FTS5_DETAIL_COLUMNS:
+      iPos = pCtx->iCol;
+      iCol = 0;
+      break;
+
+    default:
+      assert( pCtx->pConfig->eDetail==FTS5_DETAIL_NONE );
+      iPos = 0;
+      iCol = 0;
+      break;
+  }
+
+  rc = sqlite3Fts5TermsetAdd(pTermset, 0, pToken, nToken, &bPresent);
+  if( rc==SQLITE_OK && bPresent==0 ){
+    pCtx->cksum ^= sqlite3Fts5IndexEntryCksum(
+        pCtx->iRowid, iCol, iPos, 0, pToken, nToken
+    );
+  }
+
+  for(ii=0; rc==SQLITE_OK && ii<pCtx->pConfig->nPrefix; ii++){
+    const int nChar = pCtx->pConfig->aPrefix[ii];
+    int nByte = sqlite3Fts5IndexCharlenToBytelen(pToken, nToken, nChar);
+    if( nByte ){
+      rc = sqlite3Fts5TermsetAdd(pTermset, ii+1, pToken, nByte, &bPresent);
+      if( bPresent==0 ){
+        pCtx->cksum ^= sqlite3Fts5IndexEntryCksum(
+            pCtx->iRowid, iCol, iPos, ii+1, pToken, nByte
+        );
+      }
+    }
+  }
+
+  return rc;
 }
 
 /*
@@ -183280,22 +185370,37 @@ static int sqlite3Fts5StorageIntegrity(Fts5Storage *p){
       if( pConfig->bColumnsize ){
         rc = sqlite3Fts5StorageDocsize(p, ctx.iRowid, aColSize);
       }
+      if( rc==SQLITE_OK && pConfig->eDetail==FTS5_DETAIL_NONE ){
+        rc = sqlite3Fts5TermsetNew(&ctx.pTermset);
+      }
       for(i=0; rc==SQLITE_OK && i<pConfig->nCol; i++){
         if( pConfig->abUnindexed[i] ) continue;
         ctx.iCol = i;
         ctx.szCol = 0;
-        rc = sqlite3Fts5Tokenize(pConfig, 
-            FTS5_TOKENIZE_DOCUMENT,
-            (const char*)sqlite3_column_text(pScan, i+1),
-            sqlite3_column_bytes(pScan, i+1),
-            (void*)&ctx,
-            fts5StorageIntegrityCallback
-        );
-        if( pConfig->bColumnsize && ctx.szCol!=aColSize[i] ){
+        if( pConfig->eDetail==FTS5_DETAIL_COLUMNS ){
+          rc = sqlite3Fts5TermsetNew(&ctx.pTermset);
+        }
+        if( rc==SQLITE_OK ){
+          rc = sqlite3Fts5Tokenize(pConfig, 
+              FTS5_TOKENIZE_DOCUMENT,
+              (const char*)sqlite3_column_text(pScan, i+1),
+              sqlite3_column_bytes(pScan, i+1),
+              (void*)&ctx,
+              fts5StorageIntegrityCallback
+          );
+        }
+        if( rc==SQLITE_OK && pConfig->bColumnsize && ctx.szCol!=aColSize[i] ){
           rc = FTS5_CORRUPT;
         }
         aTotalSize[i] += ctx.szCol;
+        if( pConfig->eDetail==FTS5_DETAIL_COLUMNS ){
+          sqlite3Fts5TermsetFree(ctx.pTermset);
+          ctx.pTermset = 0;
+        }
       }
+      sqlite3Fts5TermsetFree(ctx.pTermset);
+      ctx.pTermset = 0;
+
       if( rc!=SQLITE_OK ) break;
     }
     rc2 = sqlite3_reset(pScan);
@@ -183564,12 +185669,13 @@ static void fts5AsciiDelete(Fts5Tokenizer *p){
 ** Create an "ascii" tokenizer.
 */
 static int fts5AsciiCreate(
-  void *pCtx, 
+  void *pUnused, 
   const char **azArg, int nArg,
   Fts5Tokenizer **ppOut
 ){
   int rc = SQLITE_OK;
   AsciiTokenizer *p = 0;
+  UNUSED_PARAM(pUnused);
   if( nArg%2 ){
     rc = SQLITE_ERROR;
   }else{
@@ -183618,7 +185724,7 @@ static void asciiFold(char *aOut, const char *aIn, int nByte){
 static int fts5AsciiTokenize(
   Fts5Tokenizer *pTokenizer,
   void *pCtx,
-  int flags,
+  int iUnused,
   const char *pText, int nText,
   int (*xToken)(void*, int, const char*, int nToken, int iStart, int iEnd)
 ){
@@ -183632,6 +185738,8 @@ static int fts5AsciiTokenize(
   char *pFold = aFold;
   unsigned char *a = p->aTokenChar;
 
+  UNUSED_PARAM(iUnused);
+
   while( is<nText && rc==SQLITE_OK ){
     int nByte;
 
@@ -183825,13 +185933,15 @@ static void fts5UnicodeDelete(Fts5Tokenizer *pTok){
 ** Create a "unicode61" tokenizer.
 */
 static int fts5UnicodeCreate(
-  void *pCtx, 
+  void *pUnused, 
   const char **azArg, int nArg,
   Fts5Tokenizer **ppOut
 ){
   int rc = SQLITE_OK;             /* Return code */
   Unicode61Tokenizer *p = 0;      /* New tokenizer object */ 
 
+  UNUSED_PARAM(pUnused);
+
   if( nArg%2 ){
     rc = SQLITE_ERROR;
   }else{
@@ -183888,7 +185998,7 @@ static int fts5UnicodeIsAlnum(Unicode61Tokenizer *p, int iCode){
 static int fts5UnicodeTokenize(
   Fts5Tokenizer *pTokenizer,
   void *pCtx,
-  int flags,
+  int iUnused,
   const char *pText, int nText,
   int (*xToken)(void*, int, const char*, int nToken, int iStart, int iEnd)
 ){
@@ -183904,6 +186014,8 @@ static int fts5UnicodeTokenize(
   int nFold = p->nFold;
   const char *pEnd = &aFold[nFold-6];
 
+  UNUSED_PARAM(iUnused);
+
   /* Each iteration of this loop gobbles up a contiguous run of separators,
   ** then the next token.  */
   while( rc==SQLITE_OK ){
@@ -184722,7 +186834,7 @@ static int sqlite3Fts5TokenizerInit(fts5_api *pApi){
   int rc = SQLITE_OK;             /* Return code */
   int i;                          /* To iterate through builtin functions */
 
-  for(i=0; rc==SQLITE_OK && i<(int)ArraySize(aBuiltin); i++){
+  for(i=0; rc==SQLITE_OK && i<ArraySize(aBuiltin); i++){
     rc = pApi->xCreateTokenizer(pApi,
         aBuiltin[i].zName,
         (void*)pApi,
@@ -184863,9 +186975,9 @@ static int sqlite3Fts5UnicodeIsalnum(int c){
     0xFFFFFFFF, 0xFC00FFFF, 0xF8000001, 0xF8000001,
   };
 
-  if( c<128 ){
+  if( (unsigned int)c<128 ){
     return ( (aAscii[c >> 5] & (1 << (c & 0x001F)))==0 );
-  }else if( c<(1<<22) ){
+  }else if( (unsigned int)c<(1<<22) ){
     unsigned int key = (((unsigned int)c)<<10) | 0x000003FF;
     int iRes = 0;
     int iHi = sizeof(aEntry)/sizeof(aEntry[0]) - 1;
@@ -185432,7 +187544,10 @@ static int sqlite3Fts5PutVarint(unsigned char *p, u64 v){
 
 
 static int sqlite3Fts5GetVarintLen(u32 iVal){
+#if 0
   if( iVal<(1 << 7 ) ) return 1;
+#endif
+  assert( iVal>=(1 << 7) );
   if( iVal<(1 << 14) ) return 2;
   if( iVal<(1 << 21) ) return 3;
   if( iVal<(1 << 28) ) return 4;
@@ -185626,7 +187741,7 @@ static int fts5VocabInitVtab(
     
     rc = fts5VocabTableType(zType, pzErr, &eType);
     if( rc==SQLITE_OK ){
-      assert( eType>=0 && eType<sizeof(azSchema)/sizeof(azSchema[0]) );
+      assert( eType>=0 && eType<ArraySize(azSchema) );
       rc = sqlite3_declare_vtab(db, azSchema[eType]);
     }
 
@@ -185679,7 +187794,7 @@ static int fts5VocabCreateMethod(
 ** Implementation of the xBestIndex method.
 */
 static int fts5VocabBestIndexMethod(
-  sqlite3_vtab *pVTab, 
+  sqlite3_vtab *pUnused,
   sqlite3_index_info *pInfo
 ){
   int i;
@@ -185689,6 +187804,8 @@ static int fts5VocabBestIndexMethod(
   int idxNum = 0;
   int nArg = 0;
 
+  UNUSED_PARAM(pUnused);
+
   for(i=0; i<pInfo->nConstraint; i++){
     struct sqlite3_index_constraint *p = &pInfo->aConstraint[i];
     if( p->usable==0 ) continue;
@@ -185821,7 +187938,7 @@ static int fts5VocabNextMethod(sqlite3_vtab_cursor *pCursor){
 
   if( pTab->eType==FTS5_VOCAB_COL ){
     for(pCsr->iCol++; pCsr->iCol<nCol; pCsr->iCol++){
-      if( pCsr->aCnt[pCsr->iCol] ) break;
+      if( pCsr->aDoc[pCsr->iCol] ) break;
     }
   }
 
@@ -185849,29 +187966,60 @@ static int fts5VocabNextMethod(sqlite3_vtab_cursor *pCursor){
 
       assert( pTab->eType==FTS5_VOCAB_COL || pTab->eType==FTS5_VOCAB_ROW );
       while( rc==SQLITE_OK ){
-        i64 dummy;
         const u8 *pPos; int nPos;   /* Position list */
         i64 iPos = 0;               /* 64-bit position read from poslist */
         int iOff = 0;               /* Current offset within position list */
 
-        rc = sqlite3Fts5IterPoslist(pCsr->pIter, 0, &pPos, &nPos, &dummy);
-        if( rc==SQLITE_OK ){
-          if( pTab->eType==FTS5_VOCAB_ROW ){
-            while( 0==sqlite3Fts5PoslistNext64(pPos, nPos, &iOff, &iPos) ){
-              pCsr->aCnt[0]++;
-            }
-            pCsr->aDoc[0]++;
-          }else{
-            int iCol = -1;
-            while( 0==sqlite3Fts5PoslistNext64(pPos, nPos, &iOff, &iPos) ){
-              int ii = FTS5_POS2COLUMN(iPos);
-              pCsr->aCnt[ii]++;
-              if( iCol!=ii ){
-                pCsr->aDoc[ii]++;
-                iCol = ii;
+        pPos = pCsr->pIter->pData;
+        nPos = pCsr->pIter->nData;
+        switch( pCsr->pConfig->eDetail ){
+          case FTS5_DETAIL_FULL:
+            pPos = pCsr->pIter->pData;
+            nPos = pCsr->pIter->nData;
+            if( pTab->eType==FTS5_VOCAB_ROW ){
+              while( 0==sqlite3Fts5PoslistNext64(pPos, nPos, &iOff, &iPos) ){
+                pCsr->aCnt[0]++;
+              }
+              pCsr->aDoc[0]++;
+            }else{
+              int iCol = -1;
+              while( 0==sqlite3Fts5PoslistNext64(pPos, nPos, &iOff, &iPos) ){
+                int ii = FTS5_POS2COLUMN(iPos);
+                pCsr->aCnt[ii]++;
+                if( iCol!=ii ){
+                  if( ii>=nCol ){
+                    rc = FTS5_CORRUPT;
+                    break;
+                  }
+                  pCsr->aDoc[ii]++;
+                  iCol = ii;
+                }
               }
             }
-          }
+            break;
+
+          case FTS5_DETAIL_COLUMNS:
+            if( pTab->eType==FTS5_VOCAB_ROW ){
+              pCsr->aDoc[0]++;
+            }else{
+              while( 0==sqlite3Fts5PoslistNext64(pPos, nPos, &iOff,&iPos) ){
+                assert_nc( iPos>=0 && iPos<nCol );
+                if( iPos>=nCol ){
+                  rc = FTS5_CORRUPT;
+                  break;
+                }
+                pCsr->aDoc[iPos]++;
+              }
+            }
+            break;
+
+          default: 
+            assert( pCsr->pConfig->eDetail==FTS5_DETAIL_NONE );
+            pCsr->aDoc[0]++;
+            break;
+        }
+
+        if( rc==SQLITE_OK ){
           rc = sqlite3Fts5IterNextScan(pCsr->pIter);
         }
 
@@ -185886,8 +188034,8 @@ static int fts5VocabNextMethod(sqlite3_vtab_cursor *pCursor){
     }
   }
 
-  if( pCsr->bEof==0 && pTab->eType==FTS5_VOCAB_COL ){
-    while( pCsr->aCnt[pCsr->iCol]==0 ) pCsr->iCol++;
+  if( rc==SQLITE_OK && pCsr->bEof==0 && pTab->eType==FTS5_VOCAB_COL ){
+    while( pCsr->aDoc[pCsr->iCol]==0 ) pCsr->iCol++;
     assert( pCsr->iCol<pCsr->pConfig->nCol );
   }
   return rc;
@@ -185899,8 +188047,8 @@ static int fts5VocabNextMethod(sqlite3_vtab_cursor *pCursor){
 static int fts5VocabFilterMethod(
   sqlite3_vtab_cursor *pCursor,   /* The cursor used for this query */
   int idxNum,                     /* Strategy index */
-  const char *idxStr,             /* Unused */
-  int nVal,                       /* Number of elements in apVal */
+  const char *zUnused,            /* Unused */
+  int nUnused,                    /* Number of elements in apVal */
   sqlite3_value **apVal           /* Arguments for the indexing scheme */
 ){
   Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
@@ -185915,6 +188063,8 @@ static int fts5VocabFilterMethod(
   sqlite3_value *pGe = 0;
   sqlite3_value *pLe = 0;
 
+  UNUSED_PARAM2(zUnused, nUnused);
+
   fts5VocabResetCursor(pCsr);
   if( idxNum & FTS5_VOCAB_TERM_EQ ) pEq = apVal[iVal++];
   if( idxNum & FTS5_VOCAB_TERM_GE ) pGe = apVal[iVal++];
@@ -185967,30 +188117,36 @@ static int fts5VocabColumnMethod(
   int iCol                        /* Index of column to read value from */
 ){
   Fts5VocabCursor *pCsr = (Fts5VocabCursor*)pCursor;
+  int eDetail = pCsr->pConfig->eDetail;
+  int eType = ((Fts5VocabTable*)(pCursor->pVtab))->eType;
+  i64 iVal = 0;
 
   if( iCol==0 ){
     sqlite3_result_text(
         pCtx, (const char*)pCsr->term.p, pCsr->term.n, SQLITE_TRANSIENT
     );
-  }
-  else if( ((Fts5VocabTable*)(pCursor->pVtab))->eType==FTS5_VOCAB_COL ){
+  }else if( eType==FTS5_VOCAB_COL ){
     assert( iCol==1 || iCol==2 || iCol==3 );
     if( iCol==1 ){
-      const char *z = pCsr->pConfig->azCol[pCsr->iCol];
-      sqlite3_result_text(pCtx, z, -1, SQLITE_STATIC);
+      if( eDetail!=FTS5_DETAIL_NONE ){
+        const char *z = pCsr->pConfig->azCol[pCsr->iCol];
+        sqlite3_result_text(pCtx, z, -1, SQLITE_STATIC);
+      }
     }else if( iCol==2 ){
-      sqlite3_result_int64(pCtx, pCsr->aDoc[pCsr->iCol]);
+      iVal = pCsr->aDoc[pCsr->iCol];
     }else{
-      sqlite3_result_int64(pCtx, pCsr->aCnt[pCsr->iCol]);
+      iVal = pCsr->aCnt[pCsr->iCol];
     }
   }else{
     assert( iCol==1 || iCol==2 );
     if( iCol==1 ){
-      sqlite3_result_int64(pCtx, pCsr->aDoc[0]);
+      iVal = pCsr->aDoc[0];
     }else{
-      sqlite3_result_int64(pCtx, pCsr->aCnt[0]);
+      iVal = pCsr->aCnt[0];
     }
   }
+
+  if( iVal>0 ) sqlite3_result_int64(pCtx, iVal);
   return SQLITE_OK;
 }
 
diff --git a/src/3rdparty/sqlite/sqlite3.h b/src/3rdparty/sqlite/sqlite3.h
index c6d1e0f233b..37d1024766c 100644
--- a/src/3rdparty/sqlite/sqlite3.h
+++ b/src/3rdparty/sqlite/sqlite3.h
@@ -111,9 +111,9 @@ extern "C" {
 ** [sqlite3_libversion_number()], [sqlite3_sourceid()],
 ** [sqlite_version()] and [sqlite_source_id()].
 */
-#define SQLITE_VERSION        "3.10.2"
-#define SQLITE_VERSION_NUMBER 3010002
-#define SQLITE_SOURCE_ID      "2016-01-20 15:27:19 17efb4209f97fb4971656086b138599a91a75ff9"
+#define SQLITE_VERSION        "3.11.1"
+#define SQLITE_VERSION_NUMBER 3011001
+#define SQLITE_SOURCE_ID      "2016-03-03 16:17:53 f047920ce16971e573bc6ec9a48b118c9de2b3a7"
 
 /*
 ** CAPI3REF: Run-Time Library Version Numbers
@@ -347,7 +347,7 @@ typedef int (*sqlite3_callback)(void*,int,char**, char**);
 ** from [sqlite3_malloc()] and passed back through the 5th parameter.
 ** To avoid memory leaks, the application should invoke [sqlite3_free()]
 ** on error message strings returned through the 5th parameter of
-** of sqlite3_exec() after the error message string is no longer needed.
+** sqlite3_exec() after the error message string is no longer needed.
 ** ^If the 5th parameter to sqlite3_exec() is not NULL and no errors
 ** occur, then sqlite3_exec() sets the pointer in its 5th parameter to
 ** NULL before returning.
@@ -5697,7 +5697,7 @@ struct sqlite3_index_info {
   /* Inputs */
   int nConstraint;           /* Number of entries in aConstraint */
   struct sqlite3_index_constraint {
-     int iColumn;              /* Column on left-hand side of constraint */
+     int iColumn;              /* Column constrained.  -1 for ROWID */
      unsigned char op;         /* Constraint operator */
      unsigned char usable;     /* True if this constraint is usable */
      int iTermOffset;          /* Used internally - xBestIndex should ignore */
@@ -8193,6 +8193,9 @@ struct Fts5PhraseIter {
 **   an OOM condition or IO error), an appropriate SQLite error code is 
 **   returned.
 **
+**   This function may be quite inefficient if used with an FTS5 table
+**   created with the "columnsize=0" option.
+**
 ** xColumnText:
 **   This function attempts to retrieve the text of column iCol of the
 **   current document. If successful, (*pz) is set to point to a buffer
@@ -8213,15 +8216,29 @@ struct Fts5PhraseIter {
 **   the query within the current row. Return SQLITE_OK if successful, or
 **   an error code (i.e. SQLITE_NOMEM) if an error occurs.
 **
+**   This API can be quite slow if used with an FTS5 table created with the
+**   "detail=none" or "detail=column" option. If the FTS5 table is created 
+**   with either "detail=none" or "detail=column" and "content=" option 
+**   (i.e. if it is a contentless table), then this API always returns 0.
+**
 ** xInst:
 **   Query for the details of phrase match iIdx within the current row.
 **   Phrase matches are numbered starting from zero, so the iIdx argument
 **   should be greater than or equal to zero and smaller than the value
 **   output by xInstCount().
 **
+**   Usually, output parameter *piPhrase is set to the phrase number, *piCol
+**   to the column in which it occurs and *piOff the token offset of the
+**   first token of the phrase. The exception is if the table was created
+**   with the offsets=0 option specified. In this case *piOff is always
+**   set to -1.
+**
 **   Returns SQLITE_OK if successful, or an error code (i.e. SQLITE_NOMEM) 
 **   if an error occurs.
 **
+**   This API can be quite slow if used with an FTS5 table created with the
+**   "detail=none" or "detail=column" option. 
+**
 ** xRowid:
 **   Returns the rowid of the current row.
 **
@@ -8305,7 +8322,7 @@ struct Fts5PhraseIter {
 **       Fts5PhraseIter iter;
 **       int iCol, iOff;
 **       for(pApi->xPhraseFirst(pFts, iPhrase, &iter, &iCol, &iOff);
-**           iOff>=0;
+**           iCol>=0;
 **           pApi->xPhraseNext(pFts, &iter, &iCol, &iOff)
 **       ){
 **         // An instance of phrase iPhrase at offset iOff of column iCol
@@ -8313,13 +8330,51 @@ struct Fts5PhraseIter {
 **
 **   The Fts5PhraseIter structure is defined above. Applications should not
 **   modify this structure directly - it should only be used as shown above
-**   with the xPhraseFirst() and xPhraseNext() API methods.
+**   with the xPhraseFirst() and xPhraseNext() API methods (and by
+**   xPhraseFirstColumn() and xPhraseNextColumn() as illustrated below).
+**
+**   This API can be quite slow if used with an FTS5 table created with the
+**   "detail=none" or "detail=column" option. If the FTS5 table is created 
+**   with either "detail=none" or "detail=column" and "content=" option 
+**   (i.e. if it is a contentless table), then this API always iterates
+**   through an empty set (all calls to xPhraseFirst() set iCol to -1).
 **
 ** xPhraseNext()
 **   See xPhraseFirst above.
+**
+** xPhraseFirstColumn()
+**   This function and xPhraseNextColumn() are similar to the xPhraseFirst()
+**   and xPhraseNext() APIs described above. The difference is that instead
+**   of iterating through all instances of a phrase in the current row, these
+**   APIs are used to iterate through the set of columns in the current row
+**   that contain one or more instances of a specified phrase. For example:
+**
+**       Fts5PhraseIter iter;
+**       int iCol;
+**       for(pApi->xPhraseFirstColumn(pFts, iPhrase, &iter, &iCol);
+**           iCol>=0;
+**           pApi->xPhraseNextColumn(pFts, &iter, &iCol)
+**       ){
+**         // Column iCol contains at least one instance of phrase iPhrase
+**       }
+**
+**   This API can be quite slow if used with an FTS5 table created with the
+**   "detail=none" option. If the FTS5 table is created with either 
+**   "detail=none" "content=" option (i.e. if it is a contentless table), 
+**   then this API always iterates through an empty set (all calls to 
+**   xPhraseFirstColumn() set iCol to -1).
+**
+**   The information accessed using this API and its companion
+**   xPhraseFirstColumn() may also be obtained using xPhraseFirst/xPhraseNext
+**   (or xInst/xInstCount). The chief advantage of this API is that it is
+**   significantly more efficient than those alternatives when used with
+**   "detail=column" tables.  
+**
+** xPhraseNextColumn()
+**   See xPhraseFirstColumn above.
 */
 struct Fts5ExtensionApi {
-  int iVersion;                   /* Currently always set to 1 */
+  int iVersion;                   /* Currently always set to 3 */
 
   void *(*xUserData)(Fts5Context*);
 
@@ -8349,8 +8404,11 @@ struct Fts5ExtensionApi {
   int (*xSetAuxdata)(Fts5Context*, void *pAux, void(*xDelete)(void*));
   void *(*xGetAuxdata)(Fts5Context*, int bClear);
 
-  void (*xPhraseFirst)(Fts5Context*, int iPhrase, Fts5PhraseIter*, int*, int*);
+  int (*xPhraseFirst)(Fts5Context*, int iPhrase, Fts5PhraseIter*, int*, int*);
   void (*xPhraseNext)(Fts5Context*, Fts5PhraseIter*, int *piCol, int *piOff);
+
+  int (*xPhraseFirstColumn)(Fts5Context*, int iPhrase, Fts5PhraseIter*, int*);
+  void (*xPhraseNextColumn)(Fts5Context*, Fts5PhraseIter*, int *piCol);
 };
 
 /* 
diff --git a/src/android/java/src/org/qtproject/qt5/android/bindings/QtService.java b/src/android/java/src/org/qtproject/qt5/android/bindings/QtService.java
index c84bdd63c3d..71acf9683e2 100644
--- a/src/android/java/src/org/qtproject/qt5/android/bindings/QtService.java
+++ b/src/android/java/src/org/qtproject/qt5/android/bindings/QtService.java
@@ -102,7 +102,7 @@ public class QtService extends Service
     {
         QtApplication.InvokeResult res = QtApplication.invokeDelegate(intent, flags, startId);
         if (res.invoked)
-            return (int) res.methodReturns;
+            return (Integer) res.methodReturns;
         else
             return super.onStartCommand(intent, flags, startId);
     }
@@ -141,7 +141,7 @@ public class QtService extends Service
     {
         QtApplication.InvokeResult res = QtApplication.invokeDelegate(intent);
         if (res.invoked)
-            return (boolean) res.methodReturns;
+            return (Boolean) res.methodReturns;
         else
             return super.onUnbind(intent);
     }
diff --git a/src/concurrent/concurrent.pro b/src/concurrent/concurrent.pro
index 2b8fef2d6aa..2a519314f35 100644
--- a/src/concurrent/concurrent.pro
+++ b/src/concurrent/concurrent.pro
@@ -7,8 +7,6 @@ win32-msvc*|win32-icc:QMAKE_LFLAGS += /BASE:0x66000000
 
 QMAKE_DOCS = $$PWD/doc/qtconcurrent.qdocconf
 
-load(qt_module)
-
 PRECOMPILED_HEADER = ../corelib/global/qt_pch.h
 
 SOURCES += \
@@ -41,3 +39,5 @@ HEADERS += \
 contains(QT_CONFIG, clock-gettime) {
     linux-*|hpux-*|solaris-*: LIBS_PRIVATE *= -lrt
 }
+
+load(qt_module)
diff --git a/src/corelib/corelib.pro b/src/corelib/corelib.pro
index 78ea489ebc0..362ac37a593 100644
--- a/src/corelib/corelib.pro
+++ b/src/corelib/corelib.pro
@@ -7,6 +7,7 @@ MODULE_CONFIG = moc resources
 !isEmpty(QT_NAMESPACE): MODULE_DEFINES = QT_NAMESPACE=$$QT_NAMESPACE
 
 CONFIG += $$MODULE_CONFIG
+DEFINES += $$MODULE_DEFINES
 DEFINES   += QT_NO_USING_NAMESPACE
 win32-msvc*|win32-icc:QMAKE_LFLAGS += /BASE:0x67000000
 irix-cc*:QMAKE_CXXFLAGS += -no_prelink -ptused
@@ -29,7 +30,6 @@ ANDROID_PERMISSIONS = \
 # variable and on FreeBSD, this variable is in the final executable itself
 freebsd: QMAKE_LFLAGS_NOUNDEF =
 
-load(qt_module)
 load(qfeatures)
 
 include(animation/animation.pri)
@@ -58,8 +58,6 @@ mac|darwin {
     LIBS_PRIVATE += -framework CoreFoundation
     LIBS_PRIVATE += -framework Foundation
 }
-win32:DEFINES-=QT_NO_CAST_TO_ASCII
-DEFINES += $$MODULE_DEFINES
 
 QMAKE_LIBS += $$QMAKE_LIBS_CORE
 
@@ -76,6 +74,11 @@ qt_conf.variable = QT_CONFIG
 
 QMAKE_PKGCONFIG_VARIABLES += host_bins qt_conf
 
+load(qt_module)
+
+# Override qt_module, so the symbols are actually included into the library.
+win32: DEFINES -= QT_NO_CAST_TO_ASCII
+
 ctest_macros_file.input = $$PWD/Qt5CTestMacros.cmake
 ctest_macros_file.output = $$DESTDIR/cmake/Qt5Core/Qt5CTestMacros.cmake
 ctest_macros_file.CONFIG = verbatim
diff --git a/src/corelib/doc/src/objectmodel/signalsandslots.qdoc b/src/corelib/doc/src/objectmodel/signalsandslots.qdoc
index 6f183d3e713..216bd985db4 100644
--- a/src/corelib/doc/src/objectmodel/signalsandslots.qdoc
+++ b/src/corelib/doc/src/objectmodel/signalsandslots.qdoc
@@ -251,7 +251,8 @@
     This example illustrates that objects can work together without needing to
     know any information about each other. To enable this, the objects only
     need to be connected together, and this can be achieved with some simple
-    QObject::connect() function calls, or with \c{uic}'s {automatic connections} feature.
+    QObject::connect() function calls, or with \c{uic}'s
+    \l{Automatic Connections}{automatic connections} feature.
 
 
     \section1 A Real Example
diff --git a/src/corelib/global/qcompilerdetection.h b/src/corelib/global/qcompilerdetection.h
index 43345394454..9a61efd1b2e 100644
--- a/src/corelib/global/qcompilerdetection.h
+++ b/src/corelib/global/qcompilerdetection.h
@@ -318,14 +318,14 @@
    and PGI C++ 5.2-4 */
 #elif !defined(Q_OS_HPUX) && (defined(__EDG) || defined(__EDG__))
 #  define Q_CC_EDG
-/* From the EDG documentation (does not seem to apply to Compaq C++):
+/* From the EDG documentation (does not seem to apply to Compaq C++ or GHS C):
    _BOOL
         Defined in C++ mode when bool is a keyword. The name of this
         predefined macro is specified by a configuration flag. _BOOL
         is the default.
    __BOOL_DEFINED
         Defined in Microsoft C++ mode when bool is a keyword. */
-#  if !defined(_BOOL) && !defined(__BOOL_DEFINED)
+#  if !defined(_BOOL) && !defined(__BOOL_DEFINED) && !defined(__ghs)
 #    error "Compiler not supported"
 #  endif
 
@@ -347,6 +347,52 @@
 /* Uses CFront, make sure to read the manual how to tweak templates. */
 #  elif defined(__ghs)
 #    define Q_CC_GHS
+#    define Q_DECL_DEPRECATED __attribute__ ((__deprecated__))
+#    define Q_FUNC_INFO       __PRETTY_FUNCTION__
+#    define Q_TYPEOF(expr)      __typeof__(expr)
+#    define Q_ALIGNOF(type)     __alignof__(type)
+#    define Q_UNREACHABLE_IMPL()
+#    if defined(__cplusplus)
+#      define Q_COMPILER_AUTO_TYPE
+#      define Q_COMPILER_STATIC_ASSERT
+#      define Q_COMPILER_RANGE_FOR
+#      if __GHS_VERSION_NUMBER >= 201505
+#        define Q_COMPILER_ALIGNAS
+#        define Q_COMPILER_ALIGNOF
+#        define Q_COMPILER_ATOMICS
+#        define Q_COMPILER_ATTRIBUTES
+#        define Q_COMPILER_AUTO_FUNCTION
+#        define Q_COMPILER_CLASS_ENUM
+#        define Q_COMPILER_CONSTEXPR
+#        define Q_COMPILER_DECLTYPE
+#        define Q_COMPILER_DEFAULT_MEMBERS
+#        define Q_COMPILER_DELETE_MEMBERS
+#        define Q_COMPILER_DELEGATING_CONSTRUCTORS
+#        define Q_COMPILER_EXPLICIT_CONVERSIONS
+#        define Q_COMPILER_EXPLICIT_OVERRIDES
+#        define Q_COMPILER_EXTERN_TEMPLATES
+#        define Q_COMPILER_INHERITING_CONSTRUCTORS
+#        define Q_COMPILER_INITIALIZER_LISTS
+#        define Q_COMPILER_LAMBDA
+#        define Q_COMPILER_NONSTATIC_MEMBER_INIT
+#        define Q_COMPILER_NOEXCEPT
+#        define Q_COMPILER_NULLPTR
+#        define Q_COMPILER_RANGE_FOR
+#        define Q_COMPILER_RAW_STRINGS
+#        define Q_COMPILER_REF_QUALIFIERS
+#        define Q_COMPILER_RVALUE_REFS
+#        define Q_COMPILER_STATIC_ASSERT
+#        define Q_COMPILER_TEMPLATE_ALIAS
+#        define Q_COMPILER_THREAD_LOCAL
+#        define Q_COMPILER_THREADSAFE_STATICS
+#        define Q_COMPILER_UDL
+#        define Q_COMPILER_UNICODE_STRINGS
+#        define Q_COMPILER_UNIFORM_INIT
+#        define Q_COMPILER_UNRESTRICTED_UNIONS
+#        define Q_COMPILER_VARIADIC_MACROS
+#        define Q_COMPILER_VARIADIC_TEMPLATES
+#      endif
+#    endif //__cplusplus
 
 #  elif defined(__DCC__)
 #    define Q_CC_DIAB
diff --git a/src/corelib/global/qglobal.cpp b/src/corelib/global/qglobal.cpp
index cbcc6d02a67..35213f8a4cb 100644
--- a/src/corelib/global/qglobal.cpp
+++ b/src/corelib/global/qglobal.cpp
@@ -426,7 +426,7 @@ Q_STATIC_ASSERT_X(QT_POINTER_SIZE == sizeof(void *), "QT_POINTER_SIZE defined in
 */
 
 /*!
-    \fn QFlags QFlags::setFlag(Enum flag, bool on) const
+    \fn QFlags QFlags::setFlag(Enum flag, bool on)
     \since 5.7
 
     Sets the indicated \a flag if \a on is \c true or unsets it if
diff --git a/src/corelib/global/qglobal.h b/src/corelib/global/qglobal.h
index d607b04192b..86ac5d0312c 100644
--- a/src/corelib/global/qglobal.h
+++ b/src/corelib/global/qglobal.h
@@ -627,6 +627,13 @@ class QDataStream;
 #  define QT_NO_PROCESS
 #endif
 
+#if defined(Q_OS_INTEGRITY)
+#  define QT_NO_CRASHHANDLER     // no popen
+#  define QT_NO_PROCESS          // no exec*, no fork
+#  define QT_NO_SYSTEMSEMAPHORE  // not needed at all in a single AddressSpace
+#  define QT_NO_MULTIPROCESS      // no system
+#endif
+
 inline void qt_noop(void) {}
 
 /* These wrap try/catch so we can switch off exceptions later.
diff --git a/src/corelib/global/qlibraryinfo.cpp b/src/corelib/global/qlibraryinfo.cpp
index c962f1b4b73..458200180e1 100644
--- a/src/corelib/global/qlibraryinfo.cpp
+++ b/src/corelib/global/qlibraryinfo.cpp
@@ -305,6 +305,8 @@ QLibraryInfo::buildDate()
 #  else
 #    define COMPILER_STRING "Clang " __clang_version__
 #  endif
+#elif defined(Q_CC_GHS)
+#  define COMPILER_STRING "GHS " QT_STRINGIFY(__GHS_VERSION_NUMBER)
 #elif defined(Q_CC_GNU)
 #  define COMPILER_STRING "GCC " __VERSION__
 #elif defined(Q_CC_MSVC)
diff --git a/src/corelib/global/qlogging.cpp b/src/corelib/global/qlogging.cpp
index 5e340dbd27f..86aa9b9e7a1 100644
--- a/src/corelib/global/qlogging.cpp
+++ b/src/corelib/global/qlogging.cpp
@@ -98,6 +98,11 @@ extern char *__progname;
 
 #if defined(Q_OS_LINUX) && (defined(__GLIBC__) || QT_HAS_INCLUDE(<sys/syscall.h>))
 #  include <sys/syscall.h>
+
+# if defined(Q_OS_ANDROID) && !defined(SYS_gettid)
+#  define SYS_gettid __NR_gettid
+# endif
+
 static long qt_gettid()
 {
     // no error handling
@@ -1191,7 +1196,7 @@ static void slog2_default_handler(QtMsgType msgType, const char *message)
 
         buffer_config.buffer_set_name = __progname;
         buffer_config.num_buffers = 1;
-        buffer_config.verbosity_level = SLOG2_INFO;
+        buffer_config.verbosity_level = SLOG2_DEBUG1;
         buffer_config.buffer_config[0].buffer_name = "default";
         buffer_config.buffer_config[0].num_pages = 8;
 
diff --git a/src/corelib/global/qnamespace.h b/src/corelib/global/qnamespace.h
index 3cd3f52cff1..1a3536d45bc 100644
--- a/src/corelib/global/qnamespace.h
+++ b/src/corelib/global/qnamespace.h
@@ -1635,7 +1635,7 @@ public:
     };
 
     enum ScrollPhase {
-        NoScrollPhase = 0, // Make public in 5.7 or asap
+        NoScrollPhase = 0,
         ScrollBegin,
         ScrollUpdate,
         ScrollEnd
diff --git a/src/corelib/global/qnamespace.qdoc b/src/corelib/global/qnamespace.qdoc
index aa3fc63833c..bc0e118a6f0 100644
--- a/src/corelib/global/qnamespace.qdoc
+++ b/src/corelib/global/qnamespace.qdoc
@@ -3089,7 +3089,8 @@
 
     This enum describes the phase of scrolling.
 
-    \omitvalue NoScrollPhase The input device doesn't support scroll phase.
+    \value NoScrollPhase The input device doesn't support scroll phase.
+    This value was introduced in Qt 5.7.
 
     \value ScrollBegin Scrolling is about to begin, but the scrolling
     distance did not yet change.
diff --git a/src/corelib/global/qsystemdetection.h b/src/corelib/global/qsystemdetection.h
index 22f01fc70ba..97f750a3a68 100644
--- a/src/corelib/global/qsystemdetection.h
+++ b/src/corelib/global/qsystemdetection.h
@@ -131,6 +131,9 @@
 #  if defined(WINCE) || defined(_WIN32_WCE)
 #    define Q_OS_WINCE
 #  elif defined(WINAPI_FAMILY)
+#    ifndef WINAPI_FAMILY_PC_APP
+#      define WINAPI_FAMILY_PC_APP WINAPI_FAMILY_APP
+#    endif
 #    if defined(WINAPI_FAMILY_PHONE_APP) && WINAPI_FAMILY==WINAPI_FAMILY_PHONE_APP
 #      define Q_OS_WINPHONE
 #      define Q_OS_WINRT
diff --git a/src/corelib/global/qt_windows.h b/src/corelib/global/qt_windows.h
index f7337fe1b5a..8ac3c2135d9 100644
--- a/src/corelib/global/qt_windows.h
+++ b/src/corelib/global/qt_windows.h
@@ -45,22 +45,14 @@
 #pragma qt_sync_stop_processing
 #endif
 
-#if defined(Q_CC_BOR)
-// Borland's windows.h does not set these correctly, resulting in
-// unusable WinSDK standard dialogs
-#ifndef WINVER
-#  define WINVER 0x0501
-#endif
-#ifndef _WIN32_WINNT
-#  define _WIN32_WINNT 0x0501
-#endif
-#endif
-
 #if defined(Q_CC_MINGW)
 // mingw's windows.h does not set _WIN32_WINNT, resulting breaking compilation
-#ifndef WINVER
-#  define WINVER 0x501
-#endif
+#  ifndef WINVER
+#    define WINVER 0x501
+#  endif
+#  ifndef _WIN32_WINNT
+#    define _WIN32_WINNT 0x0501
+#  endif
 #endif
 
 #ifndef NOMINMAX
diff --git a/src/corelib/global/qtypeinfo.h b/src/corelib/global/qtypeinfo.h
index 1200c3b5a5f..e709050011e 100644
--- a/src/corelib/global/qtypeinfo.h
+++ b/src/corelib/global/qtypeinfo.h
@@ -118,14 +118,14 @@ public:
 */
 // apply defaults for a generic QTypeInfo<T> that didn't provide the new values
 template <typename T, typename = void>
-struct QTypeInfoQuery : QTypeInfo<T>
+struct QTypeInfoQuery : public QTypeInfo<T>
 {
     enum { isRelocatable = !QTypeInfo<T>::isStatic };
 };
 
 // if QTypeInfo<T>::isRelocatable exists, use it
 template <typename T>
-struct QTypeInfoQuery<T, typename QtPrivate::QEnableIf<QTypeInfo<T>::isRelocatable || true>::Type> : QTypeInfo<T>
+struct QTypeInfoQuery<T, typename QtPrivate::QEnableIf<QTypeInfo<T>::isRelocatable || true>::Type> : public QTypeInfo<T>
 {};
 
 /*!
diff --git a/src/corelib/io/qfilesystemiterator_win.cpp b/src/corelib/io/qfilesystemiterator_win.cpp
index 2caf87a7b41..ba195b23305 100644
--- a/src/corelib/io/qfilesystemiterator_win.cpp
+++ b/src/corelib/io/qfilesystemiterator_win.cpp
@@ -37,13 +37,6 @@
 **
 ****************************************************************************/
 
-#if !defined(WINAPI_FAMILY)
-#  if _WIN32_WINNT < 0x0500
-#    undef _WIN32_WINNT
-#    define _WIN32_WINNT 0x0500
-#  endif // _WIN32_WINNT < 0x500
-#endif // !WINAPI_FAMILY
-
 #include "qfilesystemiterator_p.h"
 #include "qfilesystemengine_p.h"
 #include "qplatformdefs.h"
diff --git a/src/corelib/io/qfilesystemwatcher.cpp b/src/corelib/io/qfilesystemwatcher.cpp
index e26d412cf96..8b11830fbe9 100644
--- a/src/corelib/io/qfilesystemwatcher.cpp
+++ b/src/corelib/io/qfilesystemwatcher.cpp
@@ -317,11 +317,11 @@ QStringList QFileSystemWatcher::addPaths(const QStringList &paths)
         // Autotest override case - use the explicitly selected engine only
         const QStringRef forceName = on.midRef(26);
         if(forceName == QLatin1String("poller")) {
-            qDebug() << "QFileSystemWatcher: skipping native engine, using only polling engine";
+            qDebug("QFileSystemWatcher: skipping native engine, using only polling engine");
             d_func()->initPollerEngine();
             engine = d->poller;
         } else if(forceName == QLatin1String("native")) {
-            qDebug() << "QFileSystemWatcher: skipping polling engine, using only native engine";
+            qDebug("QFileSystemWatcher: skipping polling engine, using only native engine");
             engine = d->native;
         }
     }
diff --git a/src/corelib/io/qfilesystemwatcher_inotify.cpp b/src/corelib/io/qfilesystemwatcher_inotify.cpp
index 791429cc5a8..5564bc7dcae 100644
--- a/src/corelib/io/qfilesystemwatcher_inotify.cpp
+++ b/src/corelib/io/qfilesystemwatcher_inotify.cpp
@@ -344,7 +344,7 @@ QStringList QInotifyFileSystemWatcherEngine::removePaths(const QStringList &path
 
 void QInotifyFileSystemWatcherEngine::readFromInotify()
 {
-    // qDebug() << "QInotifyFileSystemWatcherEngine::readFromInotify";
+    // qDebug("QInotifyFileSystemWatcherEngine::readFromInotify");
 
     int buffSize = 0;
     ioctl(inotifyFd, FIONREAD, (char *) &buffSize);
diff --git a/src/corelib/io/qprocess.h b/src/corelib/io/qprocess.h
index fd835d18b1c..4ce05037619 100644
--- a/src/corelib/io/qprocess.h
+++ b/src/corelib/io/qprocess.h
@@ -269,7 +269,7 @@ Q_SIGNALS:
     void finished(int exitCode); // ### Qt 6: merge the two signals with a default value
     void finished(int exitCode, QProcess::ExitStatus exitStatus);
 #if QT_DEPRECATED_SINCE(5,6)
-    QT_MOC_COMPAT void error(QProcess::ProcessError error);
+    void error(QProcess::ProcessError error);
 #endif
     void errorOccurred(QProcess::ProcessError error);
     void stateChanged(QProcess::ProcessState state, QPrivateSignal);
diff --git a/src/corelib/io/qprocess_win.cpp b/src/corelib/io/qprocess_win.cpp
index 611ce34550f..5d8b567c8ca 100644
--- a/src/corelib/io/qprocess_win.cpp
+++ b/src/corelib/io/qprocess_win.cpp
@@ -665,7 +665,8 @@ bool QProcessPrivate::waitForReadyRead(int msecs)
             return false;
         if (WaitForSingleObjectEx(pid->hProcess, 0, false) == WAIT_OBJECT_0) {
             bool readyReadEmitted = drainOutputPipes();
-            _q_processDied();
+            if (pid)
+                _q_processDied();
             return readyReadEmitted;
         }
 
@@ -683,10 +684,7 @@ bool QProcessPrivate::waitForBytesWritten(int msecs)
     QIncrementalSleepTimer timer(msecs);
 
     forever {
-        // Check if we have any data pending: the pipe writer has
-        // bytes waiting to written, or it has written data since the
-        // last time we called stdinChannel.writer->waitForWrite().
-        bool pendingDataInPipe = stdinChannel.writer && (stdinChannel.writer->bytesToWrite() || stdinChannel.writer->hadWritten());
+        bool pendingDataInPipe = stdinChannel.writer && stdinChannel.writer->bytesToWrite();
 
         // If we don't have pending data, and our write buffer is
         // empty, we fail.
@@ -770,7 +768,8 @@ bool QProcessPrivate::waitForFinished(int msecs)
 
         if (WaitForSingleObject(pid->hProcess, timer.nextSleepTime()) == WAIT_OBJECT_0) {
             drainOutputPipes();
-            _q_processDied();
+            if (pid)
+                _q_processDied();
             return true;
         }
 
@@ -813,7 +812,6 @@ qint64 QProcessPrivate::writeToStdin(const char *data, qint64 maxlen)
         stdinChannel.writer = new QWindowsPipeWriter(stdinChannel.pipe[1], q);
         QObjectPrivate::connect(stdinChannel.writer, &QWindowsPipeWriter::canWrite,
                                 this, &QProcessPrivate::_q_canWrite);
-        stdinChannel.writer->start();
     }
 
     return stdinChannel.writer->write(data, maxlen);
diff --git a/src/corelib/io/qsettings_win.cpp b/src/corelib/io/qsettings_win.cpp
index f74f52df895..05ed51e999a 100644
--- a/src/corelib/io/qsettings_win.cpp
+++ b/src/corelib/io/qsettings_win.cpp
@@ -510,6 +510,12 @@ bool QWinSettingsPrivate::readKey(HKEY parentHandle, const QString &rSubKey, QVa
         return false;
     }
 
+    // workaround for rare cases where trailing '\0' are missing in registry
+    if (dataType == REG_SZ || dataType == REG_EXPAND_SZ)
+        dataSize += 2;
+    else if (dataType == REG_MULTI_SZ)
+        dataSize += 4;
+
     // get the value
     QByteArray data(dataSize, 0);
     res = RegQueryValueEx(handle, reinterpret_cast<const wchar_t *>(rSubkeyName.utf16()), 0, 0,
diff --git a/src/corelib/io/qstandardpaths_win.cpp b/src/corelib/io/qstandardpaths_win.cpp
index 9e3cb9ab4d1..9bd5a9e3b6e 100644
--- a/src/corelib/io/qstandardpaths_win.cpp
+++ b/src/corelib/io/qstandardpaths_win.cpp
@@ -117,6 +117,7 @@ static inline void appendTestMode(QString &path)
 // Map QStandardPaths::StandardLocation to CLSID of SHGetSpecialFolderPath()
 static int writableSpecialFolderClsid(QStandardPaths::StandardLocation type)
 {
+#ifndef Q_OS_WINCE
     static const int clsids[] = {
         CSIDL_DESKTOPDIRECTORY, // DesktopLocation
         CSIDL_PERSONAL,         // DocumentsLocation
@@ -136,6 +137,27 @@ static int writableSpecialFolderClsid(QStandardPaths::StandardLocation type)
         CSIDL_APPDATA,          // AppDataLocation ("Roaming" path)
         CSIDL_LOCAL_APPDATA,    // AppConfigLocation ("Local" path)
     };
+#else // !Q_OS_WINCE
+    static const int clsids[] = {
+        CSIDL_DESKTOPDIRECTORY, // DesktopLocation
+        CSIDL_PERSONAL,         // DocumentsLocation
+        CSIDL_FONTS,            // FontsLocation
+        CSIDL_PROGRAMS,         // ApplicationsLocation
+        CSIDL_MYMUSIC,          // MusicLocation
+        CSIDL_MYVIDEO,          // MoviesLocation
+        CSIDL_MYPICTURES,       // PicturesLocation
+        -1, -1,                 // TempLocation/HomeLocation
+        CSIDL_APPDATA,          // AppLocalDataLocation, AppLocalDataLocation = DataLocation
+        -1,                     // CacheLocation
+        CSIDL_APPDATA,          // GenericDataLocation
+        -1,                     // RuntimeLocation
+        CSIDL_APPDATA,          // ConfigLocation
+        -1, -1,                 // DownloadLocation/GenericCacheLocation
+        CSIDL_APPDATA,          // GenericConfigLocation
+        CSIDL_APPDATA,          // AppDataLocation
+        CSIDL_APPDATA,          // AppConfigLocation
+    };
+#endif // Q_OS_WINCE
 
     Q_STATIC_ASSERT(sizeof(clsids) / sizeof(clsids[0]) == size_t(QStandardPaths::AppConfigLocation + 1));
     return size_t(type) < sizeof(clsids) / sizeof(clsids[0]) ? clsids[type] : -1;
diff --git a/src/corelib/io/qtextstream.cpp b/src/corelib/io/qtextstream.cpp
index bc4a5fa538b..27b75702261 100644
--- a/src/corelib/io/qtextstream.cpp
+++ b/src/corelib/io/qtextstream.cpp
@@ -456,6 +456,10 @@ bool QTextStreamPrivate::fillReadBuffer(qint64 maxBytes)
             bytesRead = device->read(buf, sizeof(buf));
     }
 
+    // reset the Text flag.
+    if (textModeEnabled)
+        device->setTextModeEnabled(true);
+
     if (bytesRead <= 0)
         return false;
 
@@ -491,10 +495,6 @@ bool QTextStreamPrivate::fillReadBuffer(qint64 maxBytes)
     readBuffer += QString::fromLatin1(buf, bytesRead);
 #endif
 
-    // reset the Text flag.
-    if (textModeEnabled)
-        device->setTextModeEnabled(true);
-
     // remove all '\r\n' in the string.
     if (readBuffer.size() > oldReadBufferSize && textModeEnabled) {
         QChar CR = QLatin1Char('\r');
@@ -593,17 +593,18 @@ void QTextStreamPrivate::flushWriteBuffer()
     qDebug("QTextStreamPrivate::flushWriteBuffer(), device->write(\"%s\") == %d",
            qt_prettyDebug(data.constData(), qMin(data.size(),32), data.size()).constData(), int(bytesWritten));
 #endif
+
+#if defined (Q_OS_WIN)
+    // reset the text flag
+    if (textModeEnabled)
+        device->setTextModeEnabled(true);
+#endif
+
     if (bytesWritten <= 0) {
         status = QTextStream::WriteFailed;
         return;
     }
 
-#if defined (Q_OS_WIN)
-    // replace the text flag
-    if (textModeEnabled)
-        device->setTextModeEnabled(true);
-#endif
-
     // flush the file
 #ifndef QT_NO_QOBJECT
     QFileDevice *file = qobject_cast<QFileDevice *>(device);
diff --git a/src/corelib/io/qwindowspipereader.cpp b/src/corelib/io/qwindowspipereader.cpp
index 95232385b20..15fb276be92 100644
--- a/src/corelib/io/qwindowspipereader.cpp
+++ b/src/corelib/io/qwindowspipereader.cpp
@@ -38,28 +38,40 @@
 ****************************************************************************/
 
 #include "qwindowspipereader_p.h"
-#include "qwinoverlappedionotifier_p.h"
-#include <qdebug.h>
+#include "qiodevice_p.h"
 #include <qelapsedtimer.h>
-#include <qeventloop.h>
 
 QT_BEGIN_NAMESPACE
 
+QWindowsPipeReader::Overlapped::Overlapped(QWindowsPipeReader *reader)
+    : pipeReader(reader)
+{
+}
+
+void QWindowsPipeReader::Overlapped::clear()
+{
+    ZeroMemory(this, sizeof(OVERLAPPED));
+}
+
+
 QWindowsPipeReader::QWindowsPipeReader(QObject *parent)
     : QObject(parent),
       handle(INVALID_HANDLE_VALUE),
+      overlapped(this),
       readBufferMaxSize(0),
       actualReadBufferSize(0),
       stopped(true),
       readSequenceStarted(false),
+      notifiedCalled(false),
       pipeBroken(false),
-      readyReadEmitted(false)
+      readyReadPending(false),
+      inReadyRead(false)
 {
-    dataReadNotifier = new QWinOverlappedIoNotifier(this);
-    connect(dataReadNotifier, &QWinOverlappedIoNotifier::notified, this, &QWindowsPipeReader::notified);
+    connect(this, &QWindowsPipeReader::_q_queueReadyRead,
+            this, &QWindowsPipeReader::emitPendingReadyRead, Qt::QueuedConnection);
 }
 
-static bool qt_cancelIo(HANDLE handle, OVERLAPPED *overlapped)
+bool qt_cancelIo(HANDLE handle, OVERLAPPED *overlapped)
 {
     typedef BOOL (WINAPI *PtrCancelIoEx)(HANDLE, LPOVERLAPPED);
     static PtrCancelIoEx ptrCancelIoEx = 0;
@@ -88,12 +100,6 @@ void QWindowsPipeReader::setHandle(HANDLE hPipeReadEnd)
     actualReadBufferSize = 0;
     handle = hPipeReadEnd;
     pipeBroken = false;
-    readyReadEmitted = false;
-    stopped = false;
-    if (hPipeReadEnd != INVALID_HANDLE_VALUE) {
-        dataReadNotifier->setHandle(hPipeReadEnd);
-        dataReadNotifier->setEnabled(true);
-    }
 }
 
 /*!
@@ -104,19 +110,15 @@ void QWindowsPipeReader::stop()
 {
     stopped = true;
     if (readSequenceStarted) {
-        if (qt_cancelIo(handle, &overlapped)) {
-            dataReadNotifier->waitForNotified(-1, &overlapped);
-        } else {
+        if (!qt_cancelIo(handle, &overlapped)) {
             const DWORD dwError = GetLastError();
             if (dwError != ERROR_NOT_FOUND) {
                 qErrnoWarning(dwError, "QWindowsPipeReader: qt_cancelIo on handle %x failed.",
                               handle);
             }
         }
+        waitForNotification(-1);
     }
-    readSequenceStarted = false;
-    dataReadNotifier->setEnabled(false);
-    handle = INVALID_HANDLE_VALUE;
 }
 
 /*!
@@ -174,11 +176,10 @@ bool QWindowsPipeReader::canReadLine() const
     \internal
     Will be called whenever the read operation completes.
  */
-void QWindowsPipeReader::notified(quint32 numberOfBytesRead, quint32 errorCode,
-                                  OVERLAPPED *notifiedOverlapped)
+void QWindowsPipeReader::notified(DWORD errorCode, DWORD numberOfBytesRead)
 {
-    if (&overlapped != notifiedOverlapped)
-        return;
+    notifiedCalled = true;
+    readSequenceStarted = false;
 
     switch (errorCode) {
     case ERROR_SUCCESS:
@@ -202,8 +203,6 @@ void QWindowsPipeReader::notified(quint32 numberOfBytesRead, quint32 errorCode,
         break;
     }
 
-    readSequenceStarted = false;
-
     // After the reader was stopped, the only reason why this function can be called is the
     // completion of a cancellation. No signals should be emitted, and no new read sequence should
     // be started in this case.
@@ -218,13 +217,15 @@ void QWindowsPipeReader::notified(quint32 numberOfBytesRead, quint32 errorCode,
     actualReadBufferSize += numberOfBytesRead;
     readBuffer.truncate(actualReadBufferSize);
     startAsyncRead();
-    readyReadEmitted = true;
-    emit readyRead();
+    if (!readyReadPending) {
+        readyReadPending = true;
+        emit _q_queueReadyRead(QWindowsPipeReader::QPrivateSignal());
+    }
 }
 
 /*!
     \internal
-    Reads data from the socket into the readbuffer
+    Reads data from the pipe into the readbuffer.
  */
 void QWindowsPipeReader::startAsyncRead()
 {
@@ -244,41 +245,39 @@ void QWindowsPipeReader::startAsyncRead()
 
     char *ptr = readBuffer.reserve(bytesToRead);
 
+    stopped = false;
     readSequenceStarted = true;
-    ZeroMemory(&overlapped, sizeof(overlapped));
-    if (ReadFile(handle, ptr, bytesToRead, NULL, &overlapped)) {
-        // We get notified by the QWinOverlappedIoNotifier - even in the synchronous case.
-        return;
-    } else {
+    overlapped.clear();
+    if (!ReadFileEx(handle, ptr, bytesToRead, &overlapped, &readFileCompleted)) {
+        readSequenceStarted = false;
+
         const DWORD dwError = GetLastError();
         switch (dwError) {
-        case ERROR_IO_PENDING:
-            // This is not an error. We're getting notified, when data arrives.
-            return;
-        case ERROR_MORE_DATA:
-            // This is not an error. The synchronous read succeeded.
-            // We're connected to a message mode pipe and the message
-            // didn't fit into the pipe's system buffer.
-            // We're getting notified by the QWinOverlappedIoNotifier.
-            break;
         case ERROR_BROKEN_PIPE:
         case ERROR_PIPE_NOT_CONNECTED:
-            {
-                // It may happen, that the other side closes the connection directly
-                // after writing data. Then we must set the appropriate socket state.
-                readSequenceStarted = false;
-                pipeBroken = true;
-                emit pipeClosed();
-                return;
-            }
+            // It may happen, that the other side closes the connection directly
+            // after writing data. Then we must set the appropriate socket state.
+            pipeBroken = true;
+            emit pipeClosed();
+            break;
         default:
-            readSequenceStarted = false;
             emit winError(dwError, QLatin1String("QWindowsPipeReader::startAsyncRead"));
-            return;
+            break;
         }
     }
 }
 
+/*!
+    \internal
+    Called when ReadFileEx finished the read operation.
+ */
+void QWindowsPipeReader::readFileCompleted(DWORD errorCode, DWORD numberOfBytesTransfered,
+                                           OVERLAPPED *overlappedBase)
+{
+    Overlapped *overlapped = static_cast<Overlapped *>(overlappedBase);
+    overlapped->pipeReader->notified(errorCode, numberOfBytesTransfered);
+}
+
 /*!
     \internal
     Returns the number of available bytes in the pipe.
@@ -298,17 +297,60 @@ DWORD QWindowsPipeReader::checkPipeState()
     return 0;
 }
 
+bool QWindowsPipeReader::waitForNotification(int timeout)
+{
+    QElapsedTimer t;
+    t.start();
+    notifiedCalled = false;
+    int msecs = timeout;
+    while (SleepEx(msecs == -1 ? INFINITE : msecs, TRUE) == WAIT_IO_COMPLETION) {
+        if (notifiedCalled)
+            return true;
+
+        // Some other I/O completion routine was called. Wait some more.
+        msecs = qt_subtract_from_timeout(timeout, t.elapsed());
+        if (!msecs)
+            break;
+    }
+    return notifiedCalled;
+}
+
+void QWindowsPipeReader::emitPendingReadyRead()
+{
+    if (readyReadPending) {
+        readyReadPending = false;
+        inReadyRead = true;
+        emit readyRead();
+        inReadyRead = false;
+    }
+}
+
 /*!
     Waits for the completion of the asynchronous read operation.
-    Returns \c true, if we've emitted the readyRead signal.
+    Returns \c true, if we've emitted the readyRead signal (non-recursive case)
+    or readyRead will be emitted by the event loop (recursive case).
  */
 bool QWindowsPipeReader::waitForReadyRead(int msecs)
 {
     if (!readSequenceStarted)
         return false;
-    readyReadEmitted = false;
-    dataReadNotifier->waitForNotified(msecs, &overlapped);
-    return readyReadEmitted;
+
+    if (readyReadPending) {
+        if (!inReadyRead)
+            emitPendingReadyRead();
+        return true;
+    }
+
+    if (!waitForNotification(msecs))
+        return false;
+
+    if (readyReadPending) {
+        if (!inReadyRead)
+            emitPendingReadyRead();
+        return true;
+    }
+
+    return false;
 }
 
 /*!
diff --git a/src/corelib/io/qwindowspipereader_p.h b/src/corelib/io/qwindowspipereader_p.h
index d389d0cc9f6..74ff5250acf 100644
--- a/src/corelib/io/qwindowspipereader_p.h
+++ b/src/corelib/io/qwindowspipereader_p.h
@@ -51,7 +51,6 @@
 // We mean it.
 //
 
-#include <qbytearray.h>
 #include <qobject.h>
 #include <private/qringbuffer_p.h>
 
@@ -59,9 +58,6 @@
 
 QT_BEGIN_NAMESPACE
 
-
-class QWinOverlappedIoNotifier;
-
 class Q_CORE_EXPORT QWindowsPipeReader : public QObject
 {
     Q_OBJECT
@@ -70,6 +66,7 @@ public:
     ~QWindowsPipeReader();
 
     void setHandle(HANDLE hPipeReadEnd);
+    void startAsyncRead();
     void stop();
 
     void setMaxReadBufferSize(qint64 size) { readBufferMaxSize = size; }
@@ -82,31 +79,42 @@ public:
     bool waitForReadyRead(int msecs);
     bool waitForPipeClosed(int msecs);
 
-    void startAsyncRead();
     bool isReadOperationActive() const { return readSequenceStarted; }
 
 Q_SIGNALS:
     void winError(ulong, const QString &);
     void readyRead();
     void pipeClosed();
-
-private Q_SLOTS:
-    void notified(quint32 numberOfBytesRead, quint32 errorCode, OVERLAPPED *notifiedOverlapped);
+    void _q_queueReadyRead(QPrivateSignal);
 
 private:
+    static void CALLBACK readFileCompleted(DWORD errorCode, DWORD numberOfBytesTransfered,
+                                           OVERLAPPED *overlappedBase);
+    void notified(DWORD errorCode, DWORD numberOfBytesRead);
     DWORD checkPipeState();
+    bool waitForNotification(int timeout);
+    void emitPendingReadyRead();
+
+    class Overlapped : public OVERLAPPED
+    {
+        Q_DISABLE_COPY(Overlapped)
+    public:
+        explicit Overlapped(QWindowsPipeReader *reader);
+        void clear();
+        QWindowsPipeReader *pipeReader;
+    };
 
-private:
     HANDLE handle;
-    OVERLAPPED overlapped;
-    QWinOverlappedIoNotifier *dataReadNotifier;
+    Overlapped overlapped;
     qint64 readBufferMaxSize;
     QRingBuffer readBuffer;
     qint64 actualReadBufferSize;
     bool stopped;
     bool readSequenceStarted;
+    bool notifiedCalled;
     bool pipeBroken;
-    bool readyReadEmitted;
+    bool readyReadPending;
+    bool inReadyRead;
 };
 
 QT_END_NAMESPACE
diff --git a/src/corelib/io/qwindowspipewriter.cpp b/src/corelib/io/qwindowspipewriter.cpp
index c7144d2c6bc..79e7d13eb52 100644
--- a/src/corelib/io/qwindowspipewriter.cpp
+++ b/src/corelib/io/qwindowspipewriter.cpp
@@ -38,144 +38,177 @@
 ****************************************************************************/
 
 #include "qwindowspipewriter_p.h"
+#include "qiodevice_p.h"
 
 QT_BEGIN_NAMESPACE
 
-#ifndef QT_NO_THREAD
+extern bool qt_cancelIo(HANDLE handle, OVERLAPPED *overlapped);     // from qwindowspipereader.cpp
 
-QWindowsPipeWriter::QWindowsPipeWriter(HANDLE pipe, QObject * parent)
-    : QThread(parent),
-      writePipe(INVALID_HANDLE_VALUE),
-      quitNow(false),
-      hasWritten(false)
+
+QWindowsPipeWriter::Overlapped::Overlapped(QWindowsPipeWriter *pipeWriter)
+    : pipeWriter(pipeWriter)
 {
-    DuplicateHandle(GetCurrentProcess(), pipe, GetCurrentProcess(),
-                         &writePipe, 0, FALSE, DUPLICATE_SAME_ACCESS);
+}
+
+void QWindowsPipeWriter::Overlapped::clear()
+{
+    ZeroMemory(this, sizeof(OVERLAPPED));
+}
+
+
+QWindowsPipeWriter::QWindowsPipeWriter(HANDLE pipeWriteEnd, QObject *parent)
+    : QObject(parent),
+      handle(pipeWriteEnd),
+      overlapped(this),
+      numberOfBytesToWrite(0),
+      pendingBytesWrittenValue(0),
+      stopped(true),
+      writeSequenceStarted(false),
+      notifiedCalled(false),
+      bytesWrittenPending(false),
+      inBytesWritten(false)
+{
+    connect(this, &QWindowsPipeWriter::_q_queueBytesWritten,
+            this, &QWindowsPipeWriter::emitPendingBytesWrittenValue, Qt::QueuedConnection);
 }
 
 QWindowsPipeWriter::~QWindowsPipeWriter()
 {
-    lock.lock();
-    quitNow = true;
-    waitCondition.wakeOne();
-    lock.unlock();
-    if (!wait(30000))
-        terminate();
-    CloseHandle(writePipe);
+    stop();
 }
 
 bool QWindowsPipeWriter::waitForWrite(int msecs)
 {
-    QMutexLocker locker(&lock);
-    bool hadWritten = hasWritten;
-    hasWritten = false;
-    if (hadWritten)
-        return true;
-    if (!waitCondition.wait(&lock, msecs))
+    if (!writeSequenceStarted)
         return false;
-    hadWritten = hasWritten;
-    hasWritten = false;
-    return hadWritten;
+
+    if (bytesWrittenPending) {
+        if (!inBytesWritten)
+            emitPendingBytesWrittenValue();
+        return true;
+    }
+
+    if (!waitForNotification(msecs))
+        return false;
+
+    if (bytesWrittenPending) {
+        if (!inBytesWritten)
+            emitPendingBytesWrittenValue();
+        return true;
+    }
+
+    return false;
 }
 
-qint64 QWindowsPipeWriter::write(const char *ptr, qint64 maxlen)
+qint64 QWindowsPipeWriter::bytesToWrite() const
 {
-    if (!isRunning())
-        return -1;
-
-    QMutexLocker locker(&lock);
-    data.append(ptr, maxlen);
-    waitCondition.wakeOne();
-    return maxlen;
+    return numberOfBytesToWrite;
 }
 
-class QPipeWriterOverlapped
+void QWindowsPipeWriter::emitPendingBytesWrittenValue()
 {
-public:
-    QPipeWriterOverlapped()
-    {
-        overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
-    }
+    if (bytesWrittenPending) {
+        bytesWrittenPending = false;
+        const qint64 bytes = pendingBytesWrittenValue;
+        pendingBytesWrittenValue = 0;
 
-    ~QPipeWriterOverlapped()
-    {
-        CloseHandle(overlapped.hEvent);
-    }
-
-    void prepare()
-    {
-        const HANDLE hEvent = overlapped.hEvent;
-        ZeroMemory(&overlapped, sizeof overlapped);
-        overlapped.hEvent = hEvent;
-    }
-
-    OVERLAPPED *operator&()
-    {
-        return &overlapped;
-    }
-
-private:
-    OVERLAPPED overlapped;
-};
-
-void QWindowsPipeWriter::run()
-{
-    QPipeWriterOverlapped overl;
-    forever {
-        lock.lock();
-        while(data.isEmpty() && (!quitNow)) {
-            waitCondition.wakeOne();
-            waitCondition.wait(&lock);
-        }
-
-        if (quitNow) {
-            lock.unlock();
-            quitNow = false;
-            break;
-        }
-
-        QByteArray copy = data;
-
-        lock.unlock();
-
-        const char *ptrData = copy.data();
-        qint64 maxlen = copy.size();
-        qint64 totalWritten = 0;
-        overl.prepare();
-        while ((!quitNow) && totalWritten < maxlen) {
-            DWORD written = 0;
-            if (!WriteFile(writePipe, ptrData + totalWritten,
-                           maxlen - totalWritten, &written, &overl)) {
-                const DWORD writeError = GetLastError();
-                if (writeError == 0xE8/*NT_STATUS_INVALID_USER_BUFFER*/) {
-                    // give the os a rest
-                    msleep(100);
-                    continue;
-                }
-                if (writeError != ERROR_IO_PENDING) {
-                    qErrnoWarning(writeError, "QWindowsPipeWriter: async WriteFile failed.");
-                    return;
-                }
-                if (!GetOverlappedResult(writePipe, &overl, &written, TRUE)) {
-                    qErrnoWarning(GetLastError(), "QWindowsPipeWriter: GetOverlappedResult failed.");
-                    return;
-                }
-            }
-            totalWritten += written;
-#if defined QPIPEWRITER_DEBUG
-            qDebug("QWindowsPipeWriter::run() wrote %d %d/%d bytes",
-                   written, int(totalWritten), int(maxlen));
-#endif
-            lock.lock();
-            data.remove(0, written);
-            hasWritten = true;
-            lock.unlock();
-        }
-        emit bytesWritten(totalWritten);
+        inBytesWritten = true;
+        emit bytesWritten(bytes);
+        inBytesWritten = false;
         emit canWrite();
     }
 }
 
-#endif //QT_NO_THREAD
+void QWindowsPipeWriter::writeFileCompleted(DWORD errorCode, DWORD numberOfBytesTransfered,
+                                            OVERLAPPED *overlappedBase)
+{
+    Overlapped *overlapped = static_cast<Overlapped *>(overlappedBase);
+    overlapped->pipeWriter->notified(errorCode, numberOfBytesTransfered);
+}
+
+/*!
+    \internal
+    Will be called whenever the write operation completes.
+ */
+void QWindowsPipeWriter::notified(DWORD errorCode, DWORD numberOfBytesWritten)
+{
+    notifiedCalled = true;
+    writeSequenceStarted = false;
+    numberOfBytesToWrite = 0;
+
+    switch (errorCode) {
+    case ERROR_SUCCESS:
+        break;
+    case ERROR_OPERATION_ABORTED:
+        if (stopped)
+            break;
+        // fall through
+    default:
+        qErrnoWarning(errorCode, "QWindowsPipeWriter: asynchronous write failed.");
+        break;
+    }
+
+    // After the writer was stopped, the only reason why this function can be called is the
+    // completion of a cancellation. No signals should be emitted, and no new write sequence should
+    // be started in this case.
+    if (stopped)
+        return;
+
+    pendingBytesWrittenValue += qint64(numberOfBytesWritten);
+    if (!bytesWrittenPending) {
+        bytesWrittenPending = true;
+        emit _q_queueBytesWritten(QWindowsPipeWriter::QPrivateSignal());
+    }
+}
+
+bool QWindowsPipeWriter::waitForNotification(int timeout)
+{
+    QElapsedTimer t;
+    t.start();
+    notifiedCalled = false;
+    int msecs = timeout;
+    while (SleepEx(msecs == -1 ? INFINITE : msecs, TRUE) == WAIT_IO_COMPLETION) {
+        if (notifiedCalled)
+            return true;
+
+        // Some other I/O completion routine was called. Wait some more.
+        msecs = qt_subtract_from_timeout(timeout, t.elapsed());
+        if (!msecs)
+            break;
+    }
+    return notifiedCalled;
+}
+
+qint64 QWindowsPipeWriter::write(const char *ptr, qint64 maxlen)
+{
+    if (writeSequenceStarted)
+        return 0;
+
+    overlapped.clear();
+    numberOfBytesToWrite = maxlen;
+    stopped = false;
+    writeSequenceStarted = true;
+    if (!WriteFileEx(handle, ptr, maxlen, &overlapped, &writeFileCompleted)) {
+        writeSequenceStarted = false;
+        qErrnoWarning("QWindowsPipeWriter::write failed.");
+    }
+
+    return maxlen;
+}
+
+void QWindowsPipeWriter::stop()
+{
+    stopped = true;
+    if (writeSequenceStarted) {
+        if (!qt_cancelIo(handle, &overlapped)) {
+            const DWORD dwError = GetLastError();
+            if (dwError != ERROR_NOT_FOUND) {
+                qErrnoWarning(dwError, "QWindowsPipeWriter: qt_cancelIo on handle %x failed.",
+                              handle);
+            }
+        }
+        waitForNotification(-1);
+    }
+}
 
 QT_END_NAMESPACE
diff --git a/src/corelib/io/qwindowspipewriter_p.h b/src/corelib/io/qwindowspipewriter_p.h
index 49fb85ebdd3..945cbd18bfd 100644
--- a/src/corelib/io/qwindowspipewriter_p.h
+++ b/src/corelib/io/qwindowspipewriter_p.h
@@ -52,16 +52,11 @@
 //
 
 #include <qelapsedtimer.h>
-#include <qthread.h>
-#include <qmutex.h>
-#include <qwaitcondition.h>
+#include <qobject.h>
 #include <qt_windows.h>
 
 QT_BEGIN_NAMESPACE
 
-
-#ifndef QT_NO_THREAD
-
 #define SLEEPMIN 10
 #define SLEEPMAX 500
 
@@ -110,45 +105,50 @@ private:
     int nextSleep;
 };
 
-class Q_CORE_EXPORT QWindowsPipeWriter : public QThread
+class Q_CORE_EXPORT QWindowsPipeWriter : public QObject
 {
     Q_OBJECT
+public:
+    explicit QWindowsPipeWriter(HANDLE pipeWriteEnd, QObject *parent = 0);
+    ~QWindowsPipeWriter();
+
+    qint64 write(const char *data, qint64 maxlen);
+    void stop();
+    bool waitForWrite(int msecs);
+    qint64 bytesToWrite() const;
 
 Q_SIGNALS:
     void canWrite();
     void bytesWritten(qint64 bytes);
-
-public:
-    explicit QWindowsPipeWriter(HANDLE writePipe, QObject * parent = 0);
-    ~QWindowsPipeWriter();
-
-    bool waitForWrite(int msecs);
-    qint64 write(const char *data, qint64 maxlen);
-
-    qint64 bytesToWrite() const
-    {
-        QMutexLocker locker(&lock);
-        return data.size();
-    }
-
-    bool hadWritten() const
-    {
-        return hasWritten;
-    }
-
-protected:
-   void run();
+    void _q_queueBytesWritten(QPrivateSignal);
 
 private:
-    QByteArray data;
-    QWaitCondition waitCondition;
-    mutable QMutex lock;
-    HANDLE writePipe;
-    volatile bool quitNow;
-    bool hasWritten;
-};
+    static void CALLBACK writeFileCompleted(DWORD errorCode, DWORD numberOfBytesTransfered,
+                                            OVERLAPPED *overlappedBase);
+    void notified(DWORD errorCode, DWORD numberOfBytesWritten);
+    bool waitForNotification(int timeout);
+    void emitPendingBytesWrittenValue();
 
-#endif //QT_NO_THREAD
+    class Overlapped : public OVERLAPPED
+    {
+        Q_DISABLE_COPY(Overlapped)
+    public:
+        explicit Overlapped(QWindowsPipeWriter *pipeWriter);
+        void clear();
+
+        QWindowsPipeWriter *pipeWriter;
+    };
+
+    HANDLE handle;
+    Overlapped overlapped;
+    qint64 numberOfBytesToWrite;
+    qint64 pendingBytesWrittenValue;
+    bool stopped;
+    bool writeSequenceStarted;
+    bool notifiedCalled;
+    bool bytesWrittenPending;
+    bool inBytesWritten;
+};
 
 QT_END_NAMESPACE
 
diff --git a/src/corelib/itemmodels/qitemselectionmodel.cpp b/src/corelib/itemmodels/qitemselectionmodel.cpp
index dd913f957bd..b2aacfa5aa9 100644
--- a/src/corelib/itemmodels/qitemselectionmodel.cpp
+++ b/src/corelib/itemmodels/qitemselectionmodel.cpp
@@ -327,6 +327,15 @@ static void indexesFromRange(const QItemSelectionRange &range, ModelIndexContain
     }
 }
 
+template<typename ModelIndexContainer>
+static ModelIndexContainer qSelectionIndexes(const QItemSelection &selection)
+{
+    ModelIndexContainer result;
+    for (const auto &range : selection)
+        indexesFromRange(range, result);
+    return result;
+}
+
 /*!
     Returns \c true if the selection range contains no selectable item
     \since 4.7
@@ -469,20 +478,7 @@ bool QItemSelection::contains(const QModelIndex &index) const
 
 QModelIndexList QItemSelection::indexes() const
 {
-    QModelIndexList result;
-    QList<QItemSelectionRange>::const_iterator it = begin();
-    for (; it != end(); ++it)
-        indexesFromRange(*it, result);
-    return result;
-}
-
-static QVector<QPersistentModelIndex> qSelectionPersistentindexes(const QItemSelection &sel)
-{
-    QVector<QPersistentModelIndex> result;
-    QList<QItemSelectionRange>::const_iterator it = sel.constBegin();
-    for (; it != sel.constEnd(); ++it)
-        indexesFromRange(*it, result);
-    return result;
+    return qSelectionIndexes<QModelIndexList>(*this);
 }
 
 static QVector<QPair<QPersistentModelIndex, uint> > qSelectionPersistentRowLengths(const QItemSelection &sel)
@@ -892,8 +888,8 @@ void QItemSelectionModelPrivate::_q_layoutAboutToBeChanged(const QList<QPersiste
         savedPersistentRowLengths = qSelectionPersistentRowLengths(ranges);
         savedPersistentCurrentRowLengths = qSelectionPersistentRowLengths(currentSelection);
     } else {
-        savedPersistentIndexes = qSelectionPersistentindexes(ranges);
-        savedPersistentCurrentIndexes = qSelectionPersistentindexes(currentSelection);
+        savedPersistentIndexes = qSelectionIndexes<QVector<QPersistentModelIndex>>(ranges);
+        savedPersistentCurrentIndexes = qSelectionIndexes<QVector<QPersistentModelIndex>>(currentSelection);
     }
 }
 /*!
diff --git a/src/corelib/itemmodels/qsortfilterproxymodel.cpp b/src/corelib/itemmodels/qsortfilterproxymodel.cpp
index dc159c8f7c8..18cb49d4835 100644
--- a/src/corelib/itemmodels/qsortfilterproxymodel.cpp
+++ b/src/corelib/itemmodels/qsortfilterproxymodel.cpp
@@ -376,7 +376,7 @@ QModelIndex QSortFilterProxyModelPrivate::proxy_to_source(const QModelIndex &pro
     if (!proxy_index.isValid())
         return QModelIndex(); // for now; we may want to be able to set a root index later
     if (proxy_index.model() != q_func()) {
-        qWarning() << "QSortFilterProxyModel: index from wrong model passed to mapToSource";
+        qWarning("QSortFilterProxyModel: index from wrong model passed to mapToSource");
         Q_ASSERT(!"QSortFilterProxyModel: index from wrong model passed to mapToSource");
         return QModelIndex();
     }
@@ -394,7 +394,7 @@ QModelIndex QSortFilterProxyModelPrivate::source_to_proxy(const QModelIndex &sou
     if (!source_index.isValid())
         return QModelIndex(); // for now; we may want to be able to set a root index later
     if (source_index.model() != model) {
-        qWarning() << "QSortFilterProxyModel: index from wrong model passed to mapFromSource";
+        qWarning("QSortFilterProxyModel: index from wrong model passed to mapFromSource");
         Q_ASSERT(!"QSortFilterProxyModel: index from wrong model passed to mapFromSource");
         return QModelIndex();
     }
diff --git a/src/corelib/json/qjson_p.h b/src/corelib/json/qjson_p.h
index 4c628ff1feb..e5010c2da71 100644
--- a/src/corelib/json/qjson_p.h
+++ b/src/corelib/json/qjson_p.h
@@ -151,6 +151,13 @@ public:
         return *this;
     }
 };
+} // namespace QJsonPrivate
+
+template <typename T>
+class QTypeInfo<QJsonPrivate::q_littleendian<T> >
+    : public QTypeInfoMerger<QJsonPrivate::q_littleendian<T>, T> {};
+
+namespace QJsonPrivate {
 
 typedef q_littleendian<short> qle_short;
 typedef q_littleendian<unsigned short> qle_ushort;
@@ -402,7 +409,7 @@ public:
             // pack with itself, we'll discard the high part anyway
             chunk = _mm_packus_epi16(chunk, chunk);
             // unaligned 64-bit store
-            *(quint64*)&l[i] = _mm_cvtsi128_si64(chunk);
+            qUnalignedStore(l + i, _mm_cvtsi128_si64(chunk));
             i += 8;
         }
 #  endif
diff --git a/src/corelib/json/qjsondocument.cpp b/src/corelib/json/qjsondocument.cpp
index 1fde69ecf68..b2fa16d22a5 100644
--- a/src/corelib/json/qjsondocument.cpp
+++ b/src/corelib/json/qjsondocument.cpp
@@ -184,7 +184,7 @@ QJsonDocument &QJsonDocument::operator =(const QJsonDocument &other)
 QJsonDocument QJsonDocument::fromRawData(const char *data, int size, DataValidation validation)
 {
     if (quintptr(data) & 3) {
-        qWarning() <<"QJsonDocument::fromRawData: data has to have 4 byte alignment";
+        qWarning("QJsonDocument::fromRawData: data has to have 4 byte alignment");
         return QJsonDocument();
     }
 
diff --git a/src/corelib/json/qjsonparser.cpp b/src/corelib/json/qjsonparser.cpp
index 9bafcc4c5f1..2926adf10ae 100644
--- a/src/corelib/json/qjsonparser.cpp
+++ b/src/corelib/json/qjsonparser.cpp
@@ -300,7 +300,7 @@ QJsonDocument Parser::parse(QJsonParseError *error)
 {
 #ifdef PARSER_DEBUG
     indent = 0;
-    qDebug() << ">>>>> parser begin";
+    qDebug(">>>>> parser begin");
 #endif
     // allocate some space
     dataLength = qMax(end - json, (ptrdiff_t) 256);
@@ -346,7 +346,7 @@ QJsonDocument Parser::parse(QJsonParseError *error)
 
 error:
 #ifdef PARSER_DEBUG
-    qDebug() << ">>>>> parser error";
+    qDebug(">>>>> parser error");
 #endif
     if (error) {
         error->offset = json - head;
@@ -738,7 +738,7 @@ bool Parser::parseNumber(QJsonPrivate::Value *val, int baseOffset)
     }
 
     int pos = reserveSpace(sizeof(double));
-    *(quint64 *)(data + pos) = qToLittleEndian(ui);
+    qToLittleEndian(ui, reinterpret_cast<uchar *>(data + pos));
     if (current - baseOffset >= Value::MaxSize) {
         lastError = QJsonParseError::DocumentTooLarge;
         return false;
diff --git a/src/corelib/kernel/qcoreapplication.cpp b/src/corelib/kernel/qcoreapplication.cpp
index 38efc44399d..330a1eb0f51 100644
--- a/src/corelib/kernel/qcoreapplication.cpp
+++ b/src/corelib/kernel/qcoreapplication.cpp
@@ -674,7 +674,7 @@ QCoreApplication::QCoreApplication(QCoreApplicationPrivate &p)
     : QObject(p, 0)
 #endif
 {
-    init();
+    d_func()->q_ptr = this;
     // note: it is the subclasses' job to call
     // QCoreApplicationPrivate::eventDispatcher->startingUp();
 }
@@ -723,27 +723,26 @@ QCoreApplication::QCoreApplication(int &argc, char **argv
     : QObject(*new QCoreApplicationPrivate(argc, argv, _internal))
 #endif
 {
-    init();
+    d_func()->q_ptr = this;
+    d_func()->init();
 #ifndef QT_NO_QOBJECT
     QCoreApplicationPrivate::eventDispatcher->startingUp();
 #endif
 }
 
 
-// ### move to QCoreApplicationPrivate constructor?
-void QCoreApplication::init()
+void QCoreApplicationPrivate::init()
 {
-    d_ptr->q_ptr = this;
-    Q_D(QCoreApplication);
+    Q_Q(QCoreApplication);
 
-    QCoreApplicationPrivate::initLocale();
+    initLocale();
 
-    Q_ASSERT_X(!self, "QCoreApplication", "there should be only one application object");
-    QCoreApplication::self = this;
+    Q_ASSERT_X(!QCoreApplication::self, "QCoreApplication", "there should be only one application object");
+    QCoreApplication::self = q;
 
     // Store app name (so it's still available after QCoreApplication is destroyed)
     if (!coreappdata()->applicationNameSet)
-        coreappdata()->application = d_func()->appName();
+        coreappdata()->application = appName();
 
     QLoggingRegistry::instance()->init();
 
@@ -759,7 +758,7 @@ void QCoreApplication::init()
             // anywhere in the list, we can just linearly scan the lists and find the items that
             // have been removed. Once the original list is exhausted we know all the remaining
             // items have been added.
-            QStringList newPaths(libraryPaths());
+            QStringList newPaths(q->libraryPaths());
             for (int i = manualPaths->length(), j = appPaths->length(); i > 0 || j > 0; qt_noop()) {
                 if (--j < 0) {
                     newPaths.prepend((*manualPaths)[--i]);
@@ -779,28 +778,28 @@ void QCoreApplication::init()
 
 #ifndef QT_NO_QOBJECT
     // use the event dispatcher created by the app programmer (if any)
-    if (!QCoreApplicationPrivate::eventDispatcher)
-        QCoreApplicationPrivate::eventDispatcher = d->threadData->eventDispatcher.load();
+    if (!eventDispatcher)
+        eventDispatcher = threadData->eventDispatcher.load();
     // otherwise we create one
-    if (!QCoreApplicationPrivate::eventDispatcher)
-        d->createEventDispatcher();
-    Q_ASSERT(QCoreApplicationPrivate::eventDispatcher != 0);
+    if (!eventDispatcher)
+        createEventDispatcher();
+    Q_ASSERT(eventDispatcher);
 
-    if (!QCoreApplicationPrivate::eventDispatcher->parent()) {
-        QCoreApplicationPrivate::eventDispatcher->moveToThread(d->threadData->thread);
-        QCoreApplicationPrivate::eventDispatcher->setParent(this);
+    if (!eventDispatcher->parent()) {
+        eventDispatcher->moveToThread(threadData->thread);
+        eventDispatcher->setParent(q);
     }
 
-    d->threadData->eventDispatcher = QCoreApplicationPrivate::eventDispatcher;
-    d->eventDispatcherReady();
+    threadData->eventDispatcher = eventDispatcher;
+    eventDispatcherReady();
 #endif
 
 #ifdef QT_EVAL
     extern void qt_core_eval_init(QCoreApplicationPrivate::Type);
-    qt_core_eval_init(d->application_type);
+    qt_core_eval_init(application_type);
 #endif
 
-    d->processCommandLineArguments();
+    processCommandLineArguments();
 
     qt_call_pre_routines();
     qt_startup_hook();
@@ -810,7 +809,7 @@ void QCoreApplication::init()
 #endif
 
 #ifndef QT_NO_QOBJECT
-    QCoreApplicationPrivate::is_app_running = true; // No longer starting up.
+    is_app_running = true; // No longer starting up.
 #endif
 }
 
diff --git a/src/corelib/kernel/qcoreapplication.h b/src/corelib/kernel/qcoreapplication.h
index 3131265fd5e..a22e1c4f9e6 100644
--- a/src/corelib/kernel/qcoreapplication.h
+++ b/src/corelib/kernel/qcoreapplication.h
@@ -206,8 +206,6 @@ private:
     static bool notifyInternal2(QObject *receiver, QEvent *);
 #endif
 
-    void init();
-
     static QCoreApplication *self;
 
     Q_DISABLE_COPY(QCoreApplication)
diff --git a/src/corelib/kernel/qcoreapplication_p.h b/src/corelib/kernel/qcoreapplication_p.h
index 482429f0739..445bae01b46 100644
--- a/src/corelib/kernel/qcoreapplication_p.h
+++ b/src/corelib/kernel/qcoreapplication_p.h
@@ -80,6 +80,8 @@ public:
     QCoreApplicationPrivate(int &aargc,  char **aargv, uint flags);
     ~QCoreApplicationPrivate();
 
+    void init();
+
     QString appName() const;
 
 #ifdef Q_OS_MAC
diff --git a/src/corelib/kernel/qcoreevent.h b/src/corelib/kernel/qcoreevent.h
index 95068e6a674..7e962f816ed 100644
--- a/src/corelib/kernel/qcoreevent.h
+++ b/src/corelib/kernel/qcoreevent.h
@@ -325,6 +325,11 @@ private:
     friend class QGraphicsView;
     friend class QGraphicsScene;
     friend class QGraphicsScenePrivate;
+    // from QtTest:
+    friend class QSpontaneKeyEvent;
+    // needs this:
+    Q_ALWAYS_INLINE
+    void setSpontaneous() { spont = true; }
 };
 
 class Q_CORE_EXPORT QTimerEvent : public QEvent
diff --git a/src/corelib/kernel/qeventdispatcher_winrt.cpp b/src/corelib/kernel/qeventdispatcher_winrt.cpp
index bef105b184f..a6f61afc900 100644
--- a/src/corelib/kernel/qeventdispatcher_winrt.cpp
+++ b/src/corelib/kernel/qeventdispatcher_winrt.cpp
@@ -216,8 +216,10 @@ bool QEventDispatcherWinRT::processEvents(QEventLoop::ProcessEventsFlags flags)
         const QVector<HANDLE> timerHandles = d->timerIdToHandle.values().toVector();
         if (waitTime)
             emit aboutToBlock();
+        bool timerEventsSent = false;
         DWORD waitResult = WaitForMultipleObjectsEx(timerHandles.count(), timerHandles.constData(), FALSE, waitTime, TRUE);
-        if (waitResult >= WAIT_OBJECT_0 && waitResult < WAIT_OBJECT_0 + timerHandles.count()) {
+        while (waitResult >= WAIT_OBJECT_0 && waitResult < WAIT_OBJECT_0 + timerHandles.count()) {
+            timerEventsSent = true;
             const HANDLE handle = timerHandles.value(waitResult - WAIT_OBJECT_0);
             ResetEvent(handle);
             const int timerId = d->timerHandleToId.value(handle);
@@ -232,12 +234,10 @@ bool QEventDispatcherWinRT::processEvents(QEventLoop::ProcessEventsFlags flags)
             // Update timer's targetTime
             const quint64 targetTime = qt_msectime() + info.interval;
             info.targetTime = targetTime;
-            emit awake();
-            return true;
+            waitResult = WaitForMultipleObjectsEx(timerHandles.count(), timerHandles.constData(), FALSE, 0, TRUE);
         }
         emit awake();
-
-        if (userEventsSent)
+        if (timerEventsSent || userEventsSent)
             return true;
 
         // We cannot wait infinitely like on other platforms, as
diff --git a/src/corelib/kernel/qmetaobject.cpp b/src/corelib/kernel/qmetaobject.cpp
index 1c426225a5b..4f764e7e784 100644
--- a/src/corelib/kernel/qmetaobject.cpp
+++ b/src/corelib/kernel/qmetaobject.cpp
@@ -325,6 +325,24 @@ const char *QMetaObject::className() const
     \sa className()
 */
 
+/*
+    Returns \c true if the class described by this QMetaObject inherits
+    the type described by \a metaObject; otherwise returns false.
+
+    A type is considered to inherit itself.
+
+    \since 5.7
+*/
+bool QMetaObject::inherits(const QMetaObject *metaObject) const Q_DECL_NOEXCEPT
+{
+    const QMetaObject *m = this;
+    do {
+        if (metaObject == m)
+            return true;
+    } while ((m = m->d.superdata));
+    return false;
+}
+
 /*!
     \internal
 
@@ -345,14 +363,7 @@ QObject *QMetaObject::cast(QObject *obj) const
 */
 const QObject *QMetaObject::cast(const QObject *obj) const
 {
-    if (obj) {
-        const QMetaObject *m = obj->metaObject();
-        do {
-            if (m == this)
-                return obj;
-        } while ((m = m->d.superdata));
-    }
-    return 0;
+    return (obj && obj->metaObject()->inherits(this)) ? obj : nullptr;
 }
 
 #ifndef QT_NO_TRANSLATION
diff --git a/src/corelib/kernel/qobject.h b/src/corelib/kernel/qobject.h
index a070ddd805b..1f3d3dcfc72 100644
--- a/src/corelib/kernel/qobject.h
+++ b/src/corelib/kernel/qobject.h
@@ -119,8 +119,8 @@ public:
     Q_INVOKABLE explicit QObject(QObject *parent=Q_NULLPTR);
     virtual ~QObject();
 
-    virtual bool event(QEvent *);
-    virtual bool eventFilter(QObject *, QEvent *);
+    virtual bool event(QEvent *event);
+    virtual bool eventFilter(QObject *watched, QEvent *event);
 
 #ifdef Q_QDOC
     static QString tr(const char *sourceText, const char *comment = Q_NULLPTR, int n = -1);
@@ -195,9 +195,9 @@ public:
 
     inline const QObjectList &children() const { return d_ptr->children; }
 
-    void setParent(QObject *);
-    void installEventFilter(QObject *);
-    void removeEventFilter(QObject *);
+    void setParent(QObject *parent);
+    void installEventFilter(QObject *filterObj);
+    void removeEventFilter(QObject *obj);
 
     static QMetaObject::Connection connect(const QObject *sender, const char *signal,
                         const QObject *receiver, const char *member, Qt::ConnectionType = Qt::AutoConnection);
@@ -428,9 +428,9 @@ protected:
     int receivers(const char* signal) const;
     bool isSignalConnected(const QMetaMethod &signal) const;
 
-    virtual void timerEvent(QTimerEvent *);
-    virtual void childEvent(QChildEvent *);
-    virtual void customEvent(QEvent *);
+    virtual void timerEvent(QTimerEvent *event);
+    virtual void childEvent(QChildEvent *event);
+    virtual void customEvent(QEvent *event);
 
     virtual void connectNotify(const QMetaMethod &signal);
     virtual void disconnectNotify(const QMetaMethod &signal);
diff --git a/src/corelib/kernel/qobjectdefs.h b/src/corelib/kernel/qobjectdefs.h
index 2a6e24533a2..3d47bae4a08 100644
--- a/src/corelib/kernel/qobjectdefs.h
+++ b/src/corelib/kernel/qobjectdefs.h
@@ -159,6 +159,12 @@ inline void qYouForgotTheQ_OBJECT_Macro(T1, T2) {}
 #  define Q_OBJECT_NO_OVERRIDE_WARNING
 #endif
 
+#if defined(Q_CC_GNU) && !defined(Q_CC_INTEL) && Q_CC_GNU >= 600
+#  define Q_OBJECT_NO_ATTRIBUTES_WARNING    QT_WARNING_DISABLE_GCC("-Wattributes")
+#else
+#  define Q_OBJECT_NO_ATTRIBUTES_WARNING
+#endif
+
 /* qmake ignore Q_OBJECT */
 #define Q_OBJECT \
 public: \
@@ -169,10 +175,11 @@ public: \
     virtual const QMetaObject *metaObject() const; \
     virtual void *qt_metacast(const char *); \
     virtual int qt_metacall(QMetaObject::Call, int, void **); \
-    QT_WARNING_POP \
     QT_TR_FUNCTIONS \
 private: \
+    Q_OBJECT_NO_ATTRIBUTES_WARNING \
     Q_DECL_HIDDEN_STATIC_METACALL static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); \
+    QT_WARNING_POP \
     struct QPrivateSignal {};
 
 /* qmake ignore Q_OBJECT */
@@ -186,7 +193,11 @@ public: \
     void qt_check_for_QGADGET_macro(); \
     typedef void QtGadgetHelper; \
 private: \
-    Q_DECL_HIDDEN_STATIC_METACALL static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **);
+    QT_WARNING_PUSH \
+    Q_OBJECT_NO_ATTRIBUTES_WARNING \
+    Q_DECL_HIDDEN_STATIC_METACALL static void qt_static_metacall(QObject *, QMetaObject::Call, int, void **); \
+    QT_WARNING_POP \
+    /*end*/
 #endif // QT_NO_META_MACROS
 
 #else // Q_MOC_RUN
@@ -316,6 +327,7 @@ struct Q_CORE_EXPORT QMetaObject
     const char *className() const;
     const QMetaObject *superClass() const;
 
+    bool inherits(const QMetaObject *metaObject) const Q_DECL_NOEXCEPT;
     QObject *cast(QObject *obj) const;
     const QObject *cast(const QObject *obj) const;
 
diff --git a/src/corelib/kernel/qppsobject.cpp b/src/corelib/kernel/qppsobject.cpp
index 5990deb9c30..dbff997c88d 100644
--- a/src/corelib/kernel/qppsobject.cpp
+++ b/src/corelib/kernel/qppsobject.cpp
@@ -72,7 +72,7 @@ public:
     {
         int fd = qt_safe_open("/pps/.all", O_RDONLY);
         if (fd == -1) {
-            qWarning() << "qppsobject.cpp: qt_safe_open failed";
+            qWarning("qppsobject.cpp: qt_safe_open failed");
             value = -1;
         }
 
@@ -114,7 +114,7 @@ QPpsAttributeMap QPpsObjectPrivate::decode(const QByteArray &rawData, bool *ok)
         // no need to check ok in this case
         attributeMap = decodeObject(&decoder, ok);
     } else {
-        qWarning() << "QPpsObjectPrivate::decode: pps_decoder_initialize failed";
+        qWarning("QPpsObjectPrivate::decode: pps_decoder_initialize failed");
         *ok = false;
     }
 
@@ -162,7 +162,7 @@ QPpsAttribute QPpsObjectPrivate::decodeString(pps_decoder_t *decoder)
     pps_decoder_error_t error = pps_decoder_get_string(decoder, 0, &value);
 
     if (error != PPS_DECODER_OK) {
-        qWarning() << "QPpsObjectPrivate::decodeString: PPS_DECODER_GET_STRING failed";
+        qWarning("QPpsObjectPrivate::decodeString: PPS_DECODER_GET_STRING failed");
         return QPpsAttribute();
     }
 
@@ -189,19 +189,19 @@ QPpsAttribute QPpsObjectPrivate::decodeNumber(pps_decoder_t *decoder)
         case PPS_DECODER_CONVERSION_FAILED:
             error = pps_decoder_get_int64(decoder, 0, &llValue);
             if (error != PPS_DECODER_OK) {
-                qWarning() << "QPpsObjectPrivate::decodeNumber: failed to decode integer";
+                qWarning("QPpsObjectPrivate::decodeNumber: failed to decode integer");
                 return QPpsAttribute();
             }
             flags = readFlags(decoder);
             return QPpsAttributePrivate::createPpsAttribute(llValue, flags);
         default:
-            qWarning() << "QPpsObjectPrivate::decodeNumber: pps_decoder_get_int failed";
+            qWarning("QPpsObjectPrivate::decodeNumber: pps_decoder_get_int failed");
             return QPpsAttribute();
         }
     } else {
         pps_decoder_error_t error = pps_decoder_get_double(decoder, 0, &dValue);
         if (error != PPS_DECODER_OK) {
-            qWarning() << "QPpsObjectPrivate::decodeNumber: pps_decoder_get_double failed";
+            qWarning("QPpsObjectPrivate::decodeNumber: pps_decoder_get_double failed");
             return QPpsAttribute();
         }
         flags = readFlags(decoder);
@@ -215,7 +215,7 @@ QPpsAttribute QPpsObjectPrivate::decodeBool(pps_decoder_t *decoder)
     pps_decoder_error_t error = pps_decoder_get_bool(decoder, 0, &value);
 
     if (error != PPS_DECODER_OK) {
-        qWarning() << "QPpsObjectPrivate::decodeBool: pps_decoder_get_bool failed";
+        qWarning("QPpsObjectPrivate::decodeBool: pps_decoder_get_bool failed");
         return QPpsAttribute();
     }
 
@@ -278,7 +278,7 @@ QPpsAttribute QPpsObjectPrivate::decodeData(pps_decoder_t *decoder)
     case PPS_TYPE_NONE:
     case PPS_TYPE_UNKNOWN:
     default:
-        qWarning() << "QPpsObjectPrivate::decodeData: invalid pps_node_type";
+        qWarning("QPpsObjectPrivate::decodeData: invalid pps_node_type");
         return QPpsAttribute();
     }
 }
@@ -292,7 +292,7 @@ QPpsAttributeList QPpsObjectPrivate::decodeArray(pps_decoder_t *decoder, bool *o
         // Force movement to a specific index.
         pps_decoder_error_t error = pps_decoder_goto_index(decoder, i);
         if (error != PPS_DECODER_OK) {
-            qWarning() << "QPpsObjectPrivate::decodeArray: pps_decoder_goto_index failed";
+            qWarning("QPpsObjectPrivate::decodeArray: pps_decoder_goto_index failed");
             *ok = false;
             return QPpsAttributeList();
         }
@@ -319,7 +319,7 @@ QPpsAttributeMap QPpsObjectPrivate::decodeObject(pps_decoder_t *decoder, bool *o
         // Force movement to a specific index.
         pps_decoder_error_t error = pps_decoder_goto_index(decoder, i);
         if (error != PPS_DECODER_OK) {
-            qWarning() << "QPpsObjectPrivate::decodeObject: pps_decoder_goto_index failed";
+            qWarning("QPpsObjectPrivate::decodeObject: pps_decoder_goto_index failed");
             *ok = false;
             return QPpsAttributeMap();
         }
@@ -368,7 +368,7 @@ QVariant QPpsObjectPrivate::variantFromPpsAttribute(const QPpsAttribute &attribu
         return variantMapFromPpsAttributeMap(attribute.toMap());
     case QPpsAttribute::None:
     default:
-        qWarning() << "QPpsObjectPrivate::variantFromPpsAttribute: invalid attribute parameter";
+        qWarning("QPpsObjectPrivate::variantFromPpsAttribute: invalid attribute parameter");
         return QVariant();
     }
 }
@@ -385,7 +385,7 @@ QByteArray QPpsObjectPrivate::encode(const QVariantMap &ppsData, bool *ok)
         // The memory will be freed when pps_encoder_cleanup is called.
         rawData = pps_encoder_buffer(&encoder);
         if (!rawData) {
-            qWarning() << "QPpsObjectPrivate::encode: pps_encoder_buffer failed";
+            qWarning("QPpsObjectPrivate::encode: pps_encoder_buffer failed");
             *ok = false;
         }
     }
@@ -448,7 +448,7 @@ void QPpsObjectPrivate::encodeData(pps_encoder_t *encoder, const char *name, con
         errorFunction = QStringLiteral("pps_encoder_add_null");
         break;
     default:
-        qWarning() << "QPpsObjectPrivate::encodeData: the type of the parameter data is invalid";
+        qWarning("QPpsObjectPrivate::encodeData: the type of the parameter data is invalid");
         *ok = false;
         return;
     }
@@ -685,7 +685,7 @@ QByteArray QPpsObject::read(bool *ok)
 
     const int maxSize = ppsMaxSize->value;
     if (maxSize == -1) {
-        qWarning() << "QPpsObject::read: maxSize is equal to -1";
+        qWarning("QPpsObject::read: maxSize is equal to -1");
         safeAssign(ok, false);
         return QByteArray();
     }
diff --git a/src/corelib/kernel/qppsobjectprivate_p.h b/src/corelib/kernel/qppsobjectprivate_p.h
index 26d89ab7f0d..e1d54e58de0 100644
--- a/src/corelib/kernel/qppsobjectprivate_p.h
+++ b/src/corelib/kernel/qppsobjectprivate_p.h
@@ -105,7 +105,7 @@ inline bool QPpsObjectPrivate::decoderPush(pps_decoder_t *decoder, const char *n
 {
     pps_decoder_error_t error = pps_decoder_push(decoder, name);
     if (error != PPS_DECODER_OK) {
-        qWarning() << "QPpsObjectPrivate::decodeData: pps_decoder_push failed";
+        qWarning("QPpsObjectPrivate::decodeData: pps_decoder_push failed");
         return false;
     }
     return true;
@@ -115,7 +115,7 @@ inline bool QPpsObjectPrivate::decoderPop(pps_decoder_t *decoder)
 {
     pps_decoder_error_t error = pps_decoder_pop(decoder);
     if (error != PPS_DECODER_OK) {
-        qWarning() << "QPpsObjectPrivate::decodeData: pps_decoder_pop failed";
+        qWarning("QPpsObjectPrivate::decodeData: pps_decoder_pop failed");
         return false;
     }
     return true;
diff --git a/src/corelib/kernel/qsystemsemaphore_posix.cpp b/src/corelib/kernel/qsystemsemaphore_posix.cpp
index 76ab0d42eb6..61372394671 100644
--- a/src/corelib/kernel/qsystemsemaphore_posix.cpp
+++ b/src/corelib/kernel/qsystemsemaphore_posix.cpp
@@ -119,7 +119,7 @@ void QSystemSemaphorePrivate::cleanHandle()
         if (::sem_close(semaphore) == -1) {
             setErrorString(QLatin1String("QSystemSemaphore::cleanHandle (sem_close)"));
 #if defined QSYSTEMSEMAPHORE_DEBUG
-            qDebug() << QLatin1String("QSystemSemaphore::cleanHandle sem_close failed.");
+            qDebug("QSystemSemaphore::cleanHandle sem_close failed.");
 #endif
         }
         semaphore = SEM_FAILED;
@@ -129,7 +129,7 @@ void QSystemSemaphorePrivate::cleanHandle()
         if (::sem_unlink(QFile::encodeName(fileName).constData()) == -1 && errno != ENOENT) {
             setErrorString(QLatin1String("QSystemSemaphore::cleanHandle (sem_unlink)"));
 #if defined QSYSTEMSEMAPHORE_DEBUG
-            qDebug() << QLatin1String("QSystemSemaphore::cleanHandle sem_unlink failed.");
+            qDebug("QSystemSemaphore::cleanHandle sem_unlink failed.");
 #endif
         }
         createdSemaphore = false;
diff --git a/src/corelib/kernel/qsystemsemaphore_systemv.cpp b/src/corelib/kernel/qsystemsemaphore_systemv.cpp
index 69e1bf77059..f4fdfa5f589 100644
--- a/src/corelib/kernel/qsystemsemaphore_systemv.cpp
+++ b/src/corelib/kernel/qsystemsemaphore_systemv.cpp
@@ -153,7 +153,7 @@ void QSystemSemaphorePrivate::cleanHandle()
             if (-1 == semctl(semaphore, 0, IPC_RMID, 0)) {
                 setErrorString(QLatin1String("QSystemSemaphore::cleanHandle"));
 #if defined QSYSTEMSEMAPHORE_DEBUG
-                qDebug() << QLatin1String("QSystemSemaphore::cleanHandle semctl failed.");
+                qDebug("QSystemSemaphore::cleanHandle semctl failed.");
 #endif
             }
             semaphore = -1;
diff --git a/src/corelib/kernel/qsystemsemaphore_win.cpp b/src/corelib/kernel/qsystemsemaphore_win.cpp
index ca31e9d59df..236e346afe4 100644
--- a/src/corelib/kernel/qsystemsemaphore_win.cpp
+++ b/src/corelib/kernel/qsystemsemaphore_win.cpp
@@ -101,7 +101,7 @@ void QSystemSemaphorePrivate::cleanHandle()
 {
     if (semaphore && !CloseHandle(semaphore)) {
 #if defined QSYSTEMSEMAPHORE_DEBUG
-        qDebug() << QLatin1String("QSystemSemaphorePrivate::CloseHandle: sem failed");
+        qDebug("QSystemSemaphorePrivate::CloseHandle: sem failed");
 #endif
     }
     semaphore = 0;
@@ -116,7 +116,7 @@ bool QSystemSemaphorePrivate::modifySemaphore(int count)
         if (0 == ReleaseSemaphore(semaphore, count, 0)) {
             setErrorString(QLatin1String("QSystemSemaphore::modifySemaphore"));
 #if defined QSYSTEMSEMAPHORE_DEBUG
-            qDebug() << QLatin1String("QSystemSemaphore::modifySemaphore ReleaseSemaphore failed");
+            qDebug("QSystemSemaphore::modifySemaphore ReleaseSemaphore failed");
 #endif
             return false;
         }
@@ -128,7 +128,7 @@ bool QSystemSemaphorePrivate::modifySemaphore(int count)
 #endif
             setErrorString(QLatin1String("QSystemSemaphore::modifySemaphore"));
 #if defined QSYSTEMSEMAPHORE_DEBUG
-            qDebug() << QLatin1String("QSystemSemaphore::modifySemaphore WaitForSingleObject failed");
+            qDebug("QSystemSemaphore::modifySemaphore WaitForSingleObject failed");
 #endif
             return false;
         }
diff --git a/src/corelib/mimetypes/qmimeglobpattern.cpp b/src/corelib/mimetypes/qmimeglobpattern.cpp
index 5205595943a..94be5385f33 100644
--- a/src/corelib/mimetypes/qmimeglobpattern.cpp
+++ b/src/corelib/mimetypes/qmimeglobpattern.cpp
@@ -182,10 +182,8 @@ void QMimeAllGlobPatterns::addGlob(const QMimeGlobPattern &glob)
 
 void QMimeAllGlobPatterns::removeMimeType(const QString &mimeType)
 {
-    QMutableHashIterator<QString, QStringList> it(m_fastPatterns);
-    while (it.hasNext()) {
-        it.next().value().removeAll(mimeType);
-    }
+    for (auto &x : m_fastPatterns)
+        x.removeAll(mimeType);
     m_highWeightGlobs.removeMimeType(mimeType);
     m_lowWeightGlobs.removeMimeType(mimeType);
 }
diff --git a/src/corelib/mimetypes/qmimeglobpattern_p.h b/src/corelib/mimetypes/qmimeglobpattern_p.h
index 7b4ecd2f6a7..e4c74ff7fa2 100644
--- a/src/corelib/mimetypes/qmimeglobpattern_p.h
+++ b/src/corelib/mimetypes/qmimeglobpattern_p.h
@@ -130,11 +130,10 @@ public:
      */
     void removeMimeType(const QString &mimeType)
     {
-        QMutableListIterator<QMimeGlobPattern> it(*this);
-        while (it.hasNext()) {
-            if (it.next().mimeType() == mimeType)
-                it.remove();
-        }
+        auto isMimeTypeEqual = [&mimeType](const QMimeGlobPattern &pattern) {
+            return pattern.mimeType() == mimeType;
+        };
+        erase(std::remove_if(begin(), end(), isMimeTypeEqual), end());
     }
 
     void match(QMimeGlobMatchResult &result, const QString &fileName) const;
diff --git a/src/corelib/mimetypes/qmimemagicrule.cpp b/src/corelib/mimetypes/qmimemagicrule.cpp
index 528dca3ff5b..0db3407b7b0 100644
--- a/src/corelib/mimetypes/qmimemagicrule.cpp
+++ b/src/corelib/mimetypes/qmimemagicrule.cpp
@@ -48,6 +48,7 @@
 #include <QtCore/QList>
 #include <QtCore/QDebug>
 #include <qendian.h>
+#include <private/qsimd_p.h> // for qUnalignedLoad
 
 QT_BEGIN_NAMESPACE
 
@@ -163,7 +164,7 @@ bool QMimeMagicRule::matchNumber(const QByteArray &data) const
     const char *p = data.constData() + m_startPos;
     const char *e = data.constData() + qMin(data.size() - int(sizeof(T)), m_endPos + 1);
     for ( ; p <= e; ++p) {
-        if ((*reinterpret_cast<const T*>(p) & mask) == (value & mask))
+        if ((qUnalignedLoad<T>(p) & mask) == (value & mask))
             return true;
     }
 
@@ -233,7 +234,7 @@ QMimeMagicRule::QMimeMagicRule(const QString &type,
       m_mask(mask),
       m_matchFunction(nullptr)
 {
-    if (m_type == Invalid)
+    if (Q_UNLIKELY(m_type == Invalid))
         *errorString = QLatin1String("Type ") + type + QLatin1String(" is not supported");
 
     // Parse for offset as "1" or "1:10"
@@ -246,7 +247,7 @@ QMimeMagicRule::QMimeMagicRule(const QString &type,
         return;
     }
 
-    if (m_value.isEmpty()) {
+    if (Q_UNLIKELY(m_value.isEmpty())) {
         m_type = Invalid;
         if (errorString)
             *errorString = QStringLiteral("Invalid empty magic rule value");
@@ -256,7 +257,7 @@ QMimeMagicRule::QMimeMagicRule(const QString &type,
     if (m_type >= Host16 && m_type <= Byte) {
         bool ok;
         m_number = m_value.toUInt(&ok, 0); // autodetect base
-        if (!ok) {
+        if (Q_UNLIKELY(!ok)) {
             m_type = Invalid;
             if (errorString)
                 *errorString = QLatin1String("Invalid magic rule value \"") + QLatin1String(m_value) + QLatin1Char('"');
@@ -270,7 +271,7 @@ QMimeMagicRule::QMimeMagicRule(const QString &type,
         m_pattern = makePattern(m_value);
         m_pattern.squeeze();
         if (!m_mask.isEmpty()) {
-            if (m_mask.size() < 4 || !m_mask.startsWith("0x")) {
+            if (Q_UNLIKELY(m_mask.size() < 4 || !m_mask.startsWith("0x"))) {
                 m_type = Invalid;
                 if (errorString)
                     *errorString = QLatin1String("Invalid magic rule mask \"") + QLatin1String(m_mask) + QLatin1Char('"');
@@ -278,7 +279,7 @@ QMimeMagicRule::QMimeMagicRule(const QString &type,
             }
             const QByteArray &tempMask = QByteArray::fromHex(QByteArray::fromRawData(
                                                      m_mask.constData() + 2, m_mask.size() - 2));
-            if (tempMask.size() != m_pattern.size()) {
+            if (Q_UNLIKELY(tempMask.size() != m_pattern.size())) {
                 m_type = Invalid;
                 if (errorString)
                     *errorString = QLatin1String("Invalid magic rule mask size \"") + QLatin1String(m_mask) + QLatin1Char('"');
diff --git a/src/corelib/mimetypes/qmimeprovider.cpp b/src/corelib/mimetypes/qmimeprovider.cpp
index dd60c5af08b..c961c25c073 100644
--- a/src/corelib/mimetypes/qmimeprovider.cpp
+++ b/src/corelib/mimetypes/qmimeprovider.cpp
@@ -559,7 +559,7 @@ QList<QMimeType> QMimeBinaryProvider::allMimeTypes()
 void QMimeBinaryProvider::loadMimeTypePrivate(QMimeTypePrivate &data)
 {
 #ifdef QT_NO_XMLSTREAMREADER
-    qWarning() << "Cannot load mime type since QXmlStreamReader is not available.";
+    qWarning("Cannot load mime type since QXmlStreamReader is not available.");
     return;
 #else
     if (data.loaded)
@@ -597,9 +597,8 @@ void QMimeBinaryProvider::loadMimeTypePrivate(QMimeTypePrivate &data)
             const QStringRef name = xml.attributes().value(QLatin1String("type"));
             if (name.isEmpty())
                 continue;
-            if (name != data.name) {
+            if (name.compare(data.name, Qt::CaseInsensitive))
                 qWarning() << "Got name" << name << "in file" << file << "expected" << data.name;
-            }
 
             while (xml.readNextStartElement()) {
                 const QStringRef tag = xml.name();
diff --git a/src/corelib/mimetypes/qmimetypeparser.cpp b/src/corelib/mimetypes/qmimetypeparser.cpp
index 9ed345d37e8..535fa51c921 100644
--- a/src/corelib/mimetypes/qmimetypeparser.cpp
+++ b/src/corelib/mimetypes/qmimetypeparser.cpp
@@ -164,7 +164,7 @@ bool QMimeTypeParserBase::parseNumber(const QStringRef &n, int *target, QString
 {
     bool ok;
     *target = n.toInt(&ok);
-    if (!ok) {
+    if (Q_UNLIKELY(!ok)) {
         *errorMessage = QLatin1String("Not a number '") + n + QLatin1String("'.");
         return false;
     }
@@ -325,9 +325,13 @@ bool QMimeTypeParserBase::parse(QIODevice *dev, const QString &fileName, QString
         }
     }
 
-    if (reader.hasError()) {
-        if (errorMessage)
-            *errorMessage = QString::fromLatin1("An error has been encountered at line %1 of %2: %3:").arg(reader.lineNumber()).arg(fileName, reader.errorString());
+    if (Q_UNLIKELY(reader.hasError())) {
+        if (errorMessage) {
+            *errorMessage = QString::asprintf("An error has been encountered at line %lld of %ls: %ls:",
+                                              reader.lineNumber(),
+                                              qUtf16Printable(fileName),
+                                              qUtf16Printable(reader.errorString()));
+        }
         return false;
     }
 
diff --git a/src/corelib/thread/qreadwritelock.cpp b/src/corelib/thread/qreadwritelock.cpp
index 117da2e30ba..5665bf74f61 100644
--- a/src/corelib/thread/qreadwritelock.cpp
+++ b/src/corelib/thread/qreadwritelock.cpp
@@ -2,6 +2,7 @@
 **
 ** Copyright (C) 2016 The Qt Company Ltd.
 ** Copyright (C) 2016 Intel Corporation.
+** Copyright (C) 2016 Olivier Goffart <ogoffart@woboq.com>
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
@@ -45,11 +46,36 @@
 #include "qmutex.h"
 #include "qthread.h"
 #include "qwaitcondition.h"
-
 #include "qreadwritelock_p.h"
+#include "qelapsedtimer.h"
+#include "private/qfreelist_p.h"
 
 QT_BEGIN_NAMESPACE
 
+/*
+ * Implementation details of QReadWriteLock:
+ *
+ * Depending on the valued of d_ptr, the lock is in the following state:
+ *  - when d_ptr == 0x0: Unlocked (no readers, no writers) and non-recursive.
+ *  - when d_ptr & 0x1: If the least significant bit is set, we are locked for read.
+ *    In that case, d_ptr>>4 represents the number of reading threads minus 1. No writers
+ *    are waiting, and the lock is not recursive.
+ *  - when d_ptr == 0x2: We are locked for write and nobody is waiting. (no contention)
+ *  - In any other case, d_ptr points to an actual QReadWriteLockPrivate.
+ */
+
+namespace {
+enum {
+    StateMask = 0x3,
+    StateLockedForRead = 0x1,
+    StateLockedForWrite = 0x2,
+};
+const auto dummyLockedForRead = reinterpret_cast<QReadWriteLockPrivate *>(quintptr(StateLockedForRead));
+const auto dummyLockedForWrite = reinterpret_cast<QReadWriteLockPrivate *>(quintptr(StateLockedForWrite));
+inline bool isUncontendedLocked(const QReadWriteLockPrivate *d)
+{ return quintptr(d) & StateMask; }
+}
+
 /*! \class QReadWriteLock
     \inmodule QtCore
     \brief The QReadWriteLock class provides read-write locking.
@@ -116,8 +142,10 @@ QT_BEGIN_NAMESPACE
     \sa lockForRead(), lockForWrite(), RecursionMode
 */
 QReadWriteLock::QReadWriteLock(RecursionMode recursionMode)
-    : d(new QReadWriteLockPrivate(recursionMode))
-{ }
+    : d_ptr(recursionMode == Recursive ? new QReadWriteLockPrivate(true) : nullptr)
+{
+    Q_ASSERT_X(!(quintptr(d_ptr.load()) & StateMask), "QReadWriteLock::QReadWriteLock", "bad d_ptr alignment");
+}
 
 /*!
     Destroys the QReadWriteLock object.
@@ -127,6 +155,11 @@ QReadWriteLock::QReadWriteLock(RecursionMode recursionMode)
 */
 QReadWriteLock::~QReadWriteLock()
 {
+    auto d = d_ptr.load();
+    if (isUncontendedLocked(d)) {
+        qWarning("QReadWriteLock: destroying locked QReadWriteLock");
+        return;
+    }
     delete d;
 }
 
@@ -141,32 +174,9 @@ QReadWriteLock::~QReadWriteLock()
 */
 void QReadWriteLock::lockForRead()
 {
-    QMutexLocker lock(&d->mutex);
-
-    Qt::HANDLE self = 0;
-    if (d->recursive) {
-        self = QThread::currentThreadId();
-
-        QHash<Qt::HANDLE, int>::iterator it = d->currentReaders.find(self);
-        if (it != d->currentReaders.end()) {
-            ++it.value();
-            ++d->accessCount;
-            Q_ASSERT_X(d->accessCount > 0, "QReadWriteLock::lockForRead()",
-                       "Overflow in lock counter");
-            return;
-        }
-    }
-
-    while (d->accessCount < 0 || d->waitingWriters) {
-        ++d->waitingReaders;
-        d->readerWait.wait(&d->mutex);
-        --d->waitingReaders;
-    }
-    if (d->recursive)
-        d->currentReaders.insert(self, 1);
-
-    ++d->accessCount;
-    Q_ASSERT_X(d->accessCount > 0, "QReadWriteLock::lockForRead()", "Overflow in lock counter");
+    if (d_ptr.testAndSetAcquire(nullptr, dummyLockedForRead))
+        return;
+    tryLockForRead(-1);
 }
 
 /*!
@@ -187,31 +197,7 @@ void QReadWriteLock::lockForRead()
 */
 bool QReadWriteLock::tryLockForRead()
 {
-    QMutexLocker lock(&d->mutex);
-
-    Qt::HANDLE self = 0;
-    if (d->recursive) {
-        self = QThread::currentThreadId();
-
-        QHash<Qt::HANDLE, int>::iterator it = d->currentReaders.find(self);
-        if (it != d->currentReaders.end()) {
-            ++it.value();
-            ++d->accessCount;
-            Q_ASSERT_X(d->accessCount > 0, "QReadWriteLock::tryLockForRead()",
-                       "Overflow in lock counter");
-            return true;
-        }
-    }
-
-    if (d->accessCount < 0)
-        return false;
-    if (d->recursive)
-        d->currentReaders.insert(self, 1);
-
-    ++d->accessCount;
-    Q_ASSERT_X(d->accessCount > 0, "QReadWriteLock::tryLockForRead()", "Overflow in lock counter");
-
-    return true;
+    return tryLockForRead(0);
 }
 
 /*! \overload
@@ -235,36 +221,58 @@ bool QReadWriteLock::tryLockForRead()
 */
 bool QReadWriteLock::tryLockForRead(int timeout)
 {
-    QMutexLocker lock(&d->mutex);
+    // Fast case: non contended:
+    QReadWriteLockPrivate *d;
+    if (d_ptr.testAndSetAcquire(nullptr, dummyLockedForRead, d))
+        return true;
 
-    Qt::HANDLE self = 0;
-    if (d->recursive) {
-        self = QThread::currentThreadId();
-
-        QHash<Qt::HANDLE, int>::iterator it = d->currentReaders.find(self);
-        if (it != d->currentReaders.end()) {
-            ++it.value();
-            ++d->accessCount;
-            Q_ASSERT_X(d->accessCount > 0, "QReadWriteLock::tryLockForRead()",
-                       "Overflow in lock counter");
+    while (true) {
+        if (d == 0) {
+            if (!d_ptr.testAndSetAcquire(nullptr, dummyLockedForRead, d))
+                continue;
             return true;
         }
+
+        if ((quintptr(d) & StateMask) == StateLockedForRead) {
+            // locked for read, increase the counter
+            const auto val = reinterpret_cast<QReadWriteLockPrivate *>(quintptr(d) + (1U<<4));
+            Q_ASSERT_X(quintptr(val) > (1U<<4), "QReadWriteLock::tryLockForRead()",
+                       "Overflow in lock counter");
+            if (!d_ptr.testAndSetAcquire(d, val, d))
+                continue;
+            return true;
+        }
+
+        if (d == dummyLockedForWrite) {
+            // locked for write, assign a d_ptr and wait.
+            auto val = QReadWriteLockPrivate::allocate();
+            val->writerCount = 1;
+            if (!d_ptr.testAndSetOrdered(d, val, d)) {
+                val->writerCount = 0;
+                val->release();
+                continue;
+            }
+            d = val;
+        }
+        Q_ASSERT(!isUncontendedLocked(d));
+        // d is an actual pointer;
+
+        if (d->recursive)
+            return d->recursiveLockForRead(timeout);
+
+        QMutexLocker lock(&d->mutex);
+        if (d != d_ptr.load()) {
+            // d_ptr has changed: this QReadWriteLock was unlocked before we had
+            // time to lock d->mutex.
+            // We are holding a lock to a mutex within a QReadWriteLockPrivate
+            // that is already released (or even is already re-used). That's ok
+            // because the QFreeList never frees them.
+            // Just unlock d->mutex (at the end of the scope) and retry.
+            d = d_ptr.loadAcquire();
+            continue;
+        }
+        return d->lockForRead(timeout);
     }
-
-    while (d->accessCount < 0 || d->waitingWriters) {
-        ++d->waitingReaders;
-        bool success = d->readerWait.wait(&d->mutex, timeout < 0 ? ULONG_MAX : ulong(timeout));
-        --d->waitingReaders;
-        if (!success)
-            return false;
-    }
-    if (d->recursive)
-        d->currentReaders.insert(self, 1);
-
-    ++d->accessCount;
-    Q_ASSERT_X(d->accessCount > 0, "QReadWriteLock::tryLockForRead()", "Overflow in lock counter");
-
-    return true;
 }
 
 /*!
@@ -280,30 +288,7 @@ bool QReadWriteLock::tryLockForRead(int timeout)
 */
 void QReadWriteLock::lockForWrite()
 {
-    QMutexLocker lock(&d->mutex);
-
-    Qt::HANDLE self = 0;
-    if (d->recursive) {
-        self = QThread::currentThreadId();
-
-        if (d->currentWriter == self) {
-            --d->accessCount;
-            Q_ASSERT_X(d->accessCount < 0, "QReadWriteLock::lockForWrite()",
-                       "Overflow in lock counter");
-            return;
-        }
-    }
-
-    while (d->accessCount != 0) {
-        ++d->waitingWriters;
-        d->writerWait.wait(&d->mutex);
-        --d->waitingWriters;
-    }
-    if (d->recursive)
-        d->currentWriter = self;
-
-    --d->accessCount;
-    Q_ASSERT_X(d->accessCount < 0, "QReadWriteLock::lockForWrite()", "Overflow in lock counter");
+    tryLockForWrite(-1);
 }
 
 /*!
@@ -323,30 +308,7 @@ void QReadWriteLock::lockForWrite()
 */
 bool QReadWriteLock::tryLockForWrite()
 {
-    QMutexLocker lock(&d->mutex);
-
-    Qt::HANDLE self = 0;
-    if (d->recursive) {
-        self = QThread::currentThreadId();
-
-        if (d->currentWriter == self) {
-            --d->accessCount;
-            Q_ASSERT_X(d->accessCount < 0, "QReadWriteLock::lockForWrite()",
-                       "Overflow in lock counter");
-            return true;
-        }
-    }
-
-    if (d->accessCount != 0)
-        return false;
-    if (d->recursive)
-        d->currentWriter = self;
-
-    --d->accessCount;
-    Q_ASSERT_X(d->accessCount < 0, "QReadWriteLock::tryLockForWrite()",
-               "Overflow in lock counter");
-
-    return true;
+    return tryLockForWrite(0);
 }
 
 /*! \overload
@@ -370,36 +332,48 @@ bool QReadWriteLock::tryLockForWrite()
 */
 bool QReadWriteLock::tryLockForWrite(int timeout)
 {
-    QMutexLocker lock(&d->mutex);
+    // Fast case: non contended:
+    QReadWriteLockPrivate *d;
+    if (d_ptr.testAndSetAcquire(nullptr, dummyLockedForWrite, d))
+        return true;
 
-    Qt::HANDLE self = 0;
-    if (d->recursive) {
-        self = QThread::currentThreadId();
-
-        if (d->currentWriter == self) {
-            --d->accessCount;
-            Q_ASSERT_X(d->accessCount < 0, "QReadWriteLock::lockForWrite()",
-                       "Overflow in lock counter");
+    while (true) {
+        if (d == 0) {
+            if (!d_ptr.testAndSetAcquire(d, dummyLockedForWrite, d))
+                continue;
             return true;
         }
+
+        if (isUncontendedLocked(d)) {
+            // locked for either read or write, assign a d_ptr and wait.
+            auto val = QReadWriteLockPrivate::allocate();
+            if (d == dummyLockedForWrite)
+                val->writerCount = 1;
+            else
+                val->readerCount = (quintptr(d) >> 4) + 1;
+            if (!d_ptr.testAndSetOrdered(d, val, d)) {
+                val->writerCount = val->readerCount = 0;
+                val->release();
+                continue;
+            }
+            d = val;
+        }
+        Q_ASSERT(!isUncontendedLocked(d));
+        // d is an actual pointer;
+
+        if (d->recursive)
+            return d->recursiveLockForWrite(timeout);
+
+        QMutexLocker lock(&d->mutex);
+        if (d != d_ptr.load()) {
+            // The mutex was unlocked before we had time to lock the mutex.
+            // We are holding to a mutex within a QReadWriteLockPrivate that is already released
+            // (or even is already re-used) but that's ok because the QFreeList never frees them.
+            d = d_ptr.loadAcquire();
+            continue;
+        }
+        return d->lockForWrite(timeout);
     }
-
-    while (d->accessCount != 0) {
-        ++d->waitingWriters;
-        bool success = d->writerWait.wait(&d->mutex, timeout < 0 ? ULONG_MAX : ulong(timeout));
-        --d->waitingWriters;
-
-        if (!success)
-            return false;
-    }
-    if (d->recursive)
-        d->currentWriter = self;
-
-    --d->accessCount;
-    Q_ASSERT_X(d->accessCount < 0, "QReadWriteLock::tryLockForWrite()",
-               "Overflow in lock counter");
-
-    return true;
 }
 
 /*!
@@ -412,36 +386,246 @@ bool QReadWriteLock::tryLockForWrite(int timeout)
 */
 void QReadWriteLock::unlock()
 {
-    QMutexLocker lock(&d->mutex);
+    QReadWriteLockPrivate *d = d_ptr.load();
+    while (true) {
+        Q_ASSERT_X(d, "QReadWriteLock::unlock()", "Cannot unlock an unlocked lock");
 
-    Q_ASSERT_X(d->accessCount != 0, "QReadWriteLock::unlock()", "Cannot unlock an unlocked lock");
+        // Fast case: no contention: (no waiters, no other readers)
+        if (quintptr(d) <= 2) { // 1 or 2 (StateLockedForRead or StateLockedForWrite)
+            if (!d_ptr.testAndSetRelease(d, nullptr, d))
+                continue;
+            return;
+        }
+
+        if ((quintptr(d) & StateMask) == StateLockedForRead) {
+            Q_ASSERT(quintptr(d) > (1U<<4)); //otherwise that would be the fast case
+            // Just decrease the reader's count.
+            auto val = reinterpret_cast<QReadWriteLockPrivate *>(quintptr(d) - (1U<<4));
+            if (!d_ptr.testAndSetRelease(d, val, d))
+                continue;
+            return;
+        }
+
+        Q_ASSERT(!isUncontendedLocked(d));
 
-    bool unlocked = false;
-    if (d->accessCount > 0) {
-        // releasing a read lock
         if (d->recursive) {
-            Qt::HANDLE self = QThread::currentThreadId();
-            QHash<Qt::HANDLE, int>::iterator it = d->currentReaders.find(self);
-            if (it != d->currentReaders.end()) {
-                if (--it.value() <= 0)
-                    d->currentReaders.erase(it);
+            d->recursiveUnlock();
+            return;
+        }
+
+        QMutexLocker locker(&d->mutex);
+        if (d->writerCount) {
+            Q_ASSERT(d->writerCount == 1);
+            Q_ASSERT(d->readerCount == 0);
+            d->writerCount = 0;
+        } else {
+            Q_ASSERT(d->readerCount > 0);
+            d->readerCount--;
+            if (d->readerCount > 0)
+                return;
+        }
+
+        if (d->waitingReaders || d->waitingWriters) {
+            d->unlock();
+        } else {
+            Q_ASSERT(d_ptr.load() == d); // should not change when we still hold the mutex
+            d_ptr.storeRelease(nullptr);
+            d->release();
+        }
+        return;
+    }
+}
+
+/*! \internal  Helper for QWaitCondition::wait */
+QReadWriteLock::StateForWaitCondition QReadWriteLock::stateForWaitCondition() const
+{
+    QReadWriteLockPrivate *d = d_ptr.load();
+    switch (quintptr(d) & StateMask) {
+    case StateLockedForRead: return LockedForRead;
+    case StateLockedForWrite: return LockedForWrite;
+    }
+
+    if (!d)
+        return Unlocked;
+    if (d->writerCount > 1)
+        return RecursivelyLocked;
+    else if (d->writerCount == 1)
+        return LockedForWrite;
+    return LockedForRead;
+
+}
+
+bool QReadWriteLockPrivate::lockForRead(int timeout)
+{
+    Q_ASSERT(!mutex.tryLock()); // mutex must be locked when entering this function
+
+    QElapsedTimer t;
+    if (timeout > 0)
+        t.start();
+
+    while (waitingWriters || writerCount) {
+        if (timeout == 0)
+            return false;
+        if (timeout > 0) {
+            auto elapsed = t.elapsed();
+            if (elapsed > timeout)
+                return false;
+            waitingReaders++;
+            readerCond.wait(&mutex, timeout - elapsed);
+        } else {
+            waitingReaders++;
+            readerCond.wait(&mutex);
+        }
+        waitingReaders--;
+    }
+    readerCount++;
+    Q_ASSERT(writerCount == 0);
+    return true;
+}
+
+bool QReadWriteLockPrivate::lockForWrite(int timeout)
+{
+    Q_ASSERT(!mutex.tryLock()); // mutex must be locked when entering this function
+
+    QElapsedTimer t;
+    if (timeout > 0)
+        t.start();
+
+    while (readerCount || writerCount) {
+        if (timeout == 0)
+            return false;
+        if (timeout > 0) {
+            auto elapsed = t.elapsed();
+            if (elapsed > timeout) {
+                if (waitingReaders && !waitingWriters && !writerCount) {
+                    // We timed out and now there is no more writers or waiting writers, but some
+                    // readers were queueud (probably because of us). Wake the waiting readers.
+                    readerCond.wakeAll();
+                }
+                return false;
             }
+            waitingWriters++;
+            writerCond.wait(&mutex, timeout - elapsed);
+        } else {
+            waitingWriters++;
+            writerCond.wait(&mutex);
         }
-
-        unlocked = --d->accessCount == 0;
-    } else if (d->accessCount < 0 && ++d->accessCount == 0) {
-        // released a write lock
-        unlocked = true;
-        d->currentWriter = 0;
+        waitingWriters--;
     }
 
-    if (unlocked) {
-        if (d->waitingWriters) {
-            d->writerWait.wakeOne();
-        } else if (d->waitingReaders) {
-            d->readerWait.wakeAll();
+    Q_ASSERT(writerCount == 0);
+    Q_ASSERT(readerCount == 0);
+    writerCount = 1;
+    return true;
+}
+
+void QReadWriteLockPrivate::unlock()
+{
+    Q_ASSERT(!mutex.tryLock()); // mutex must be locked when entering this function
+    if (waitingWriters)
+        writerCond.wakeOne();
+    else if (waitingReaders)
+        readerCond.wakeAll();
+}
+
+bool QReadWriteLockPrivate::recursiveLockForRead(int timeout)
+{
+    Q_ASSERT(recursive);
+    QMutexLocker lock(&mutex);
+
+    Qt::HANDLE self = QThread::currentThreadId();
+
+    auto it = currentReaders.find(self);
+    if (it != currentReaders.end()) {
+        ++it.value();
+        return true;
+    }
+
+    if (!lockForRead(timeout))
+        return false;
+
+    currentReaders.insert(self, 1);
+    return true;
+}
+
+bool QReadWriteLockPrivate::recursiveLockForWrite(int timeout)
+{
+    Q_ASSERT(recursive);
+    QMutexLocker lock(&mutex);
+
+    Qt::HANDLE self = QThread::currentThreadId();
+    if (currentWriter == self) {
+        writerCount++;
+        return true;
+    }
+
+    if (!lockForWrite(timeout))
+        return false;
+
+    currentWriter = self;
+    return true;
+}
+
+void QReadWriteLockPrivate::recursiveUnlock()
+{
+    Q_ASSERT(recursive);
+    QMutexLocker lock(&mutex);
+
+    Qt::HANDLE self = QThread::currentThreadId();
+    if (self == currentWriter) {
+        if (--writerCount > 0)
+            return;
+        currentWriter = 0;
+    } else {
+        auto it = currentReaders.find(self);
+        if (it == currentReaders.end()) {
+            qWarning("QReadWriteLock::unlock: unlocking from a thread that did not lock");
+            return;
+        } else {
+            if (--it.value() <= 0) {
+                currentReaders.erase(it);
+                readerCount--;
+            }
+            if (readerCount)
+                return;
         }
     }
+
+    unlock();
+}
+
+// The freelist management
+namespace {
+struct FreeListConstants : QFreeListDefaultConstants {
+    enum { BlockCount = 4, MaxIndex=0xffff };
+    static const int Sizes[BlockCount];
+};
+const int FreeListConstants::Sizes[FreeListConstants::BlockCount] = {
+    16,
+    128,
+    1024,
+    FreeListConstants::MaxIndex - (16 + 128 + 1024)
+};
+
+typedef QFreeList<QReadWriteLockPrivate, FreeListConstants> FreeList;
+Q_GLOBAL_STATIC(FreeList, freelist);
+}
+
+QReadWriteLockPrivate *QReadWriteLockPrivate::allocate()
+{
+    int i = freelist->next();
+    QReadWriteLockPrivate *d = &(*freelist)[i];
+    d->id = i;
+    Q_ASSERT(!d->recursive);
+    Q_ASSERT(!d->waitingReaders && !d->waitingReaders && !d->readerCount && !d->writerCount);
+    return d;
+}
+
+void QReadWriteLockPrivate::release()
+{
+    Q_ASSERT(!recursive);
+    Q_ASSERT(!waitingReaders && !waitingReaders && !readerCount && !writerCount);
+    freelist->release(id);
 }
 
 /*!
diff --git a/src/corelib/thread/qreadwritelock.h b/src/corelib/thread/qreadwritelock.h
index b7e2092e38b..777efdb3bfb 100644
--- a/src/corelib/thread/qreadwritelock.h
+++ b/src/corelib/thread/qreadwritelock.h
@@ -47,7 +47,7 @@ QT_BEGIN_NAMESPACE
 
 #ifndef QT_NO_THREAD
 
-struct QReadWriteLockPrivate;
+class QReadWriteLockPrivate;
 
 class Q_CORE_EXPORT QReadWriteLock
 {
@@ -69,8 +69,10 @@ public:
 
 private:
     Q_DISABLE_COPY(QReadWriteLock)
-    QReadWriteLockPrivate *d;
+    QAtomicPointer<QReadWriteLockPrivate> d_ptr;
 
+    enum StateForWaitCondition { LockedForRead, LockedForWrite, Unlocked, RecursivelyLocked };
+    StateForWaitCondition stateForWaitCondition() const;
     friend class QWaitCondition;
 };
 
diff --git a/src/corelib/thread/qreadwritelock_p.h b/src/corelib/thread/qreadwritelock_p.h
index 1f6f73c8e35..285f017655e 100644
--- a/src/corelib/thread/qreadwritelock_p.h
+++ b/src/corelib/thread/qreadwritelock_p.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2016 The Qt Company Ltd.
+** Copyright (C) 2016 Olivier Goffart <ogoffart@woboq.com>
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
@@ -53,29 +54,47 @@
 
 #include <QtCore/qglobal.h>
 #include <QtCore/qhash.h>
+#include <QtCore/QWaitCondition>
 
 #ifndef QT_NO_THREAD
 
 QT_BEGIN_NAMESPACE
 
-struct QReadWriteLockPrivate
+class QReadWriteLockPrivate
 {
-    QReadWriteLockPrivate(QReadWriteLock::RecursionMode recursionMode)
-        : accessCount(0), waitingReaders(0), waitingWriters(0),
-          recursive(recursionMode == QReadWriteLock::Recursive), currentWriter(0)
-    { }
+public:
+    QReadWriteLockPrivate(bool isRecursive = false)
+        : readerCount(0), writerCount(0), waitingReaders(0), waitingWriters(0),
+        recursive(isRecursive), id(0) {}
 
     QMutex mutex;
-    QWaitCondition readerWait;
-    QWaitCondition writerWait;
-
-    int accessCount;
+    QWaitCondition writerCond;
+    QWaitCondition readerCond;
+    int readerCount;
+    int writerCount;
     int waitingReaders;
     int waitingWriters;
-
     bool recursive;
+
+    //Called with the mutex locked
+    bool lockForWrite(int timeout);
+    bool lockForRead(int timeout);
+    void unlock();
+
+    //memory management
+    int id;
+    void release();
+    static QReadWriteLockPrivate *allocate();
+
+    // Recusive mutex handling
     Qt::HANDLE currentWriter;
     QHash<Qt::HANDLE, int> currentReaders;
+
+    // called with the mutex unlocked
+    bool recursiveLockForWrite(int timeout);
+    bool recursiveLockForRead(int timeout);
+    void recursiveUnlock();
+
 };
 
 QT_END_NAMESPACE
diff --git a/src/corelib/thread/qthread.cpp b/src/corelib/thread/qthread.cpp
index 48b94abae5a..8a797772fcd 100644
--- a/src/corelib/thread/qthread.cpp
+++ b/src/corelib/thread/qthread.cpp
@@ -310,8 +310,9 @@ QThreadPrivate::~QThreadPrivate()
     The effect of the \a priority parameter is dependent on the
     operating system's scheduling policy. In particular, the \a priority
     will be ignored on systems that do not support thread priorities
-    (such as on Linux, see http://linux.die.net/man/2/sched_setscheduler
-    for more details).
+    (such as on Linux, see the
+    \l {http://linux.die.net/man/2/sched_setscheduler}{sched_setscheduler}
+    documentation for more details).
 
     \sa run(), terminate()
 */
diff --git a/src/corelib/thread/qthread_win.cpp b/src/corelib/thread/qthread_win.cpp
index 635282d5c4a..ef1799a021a 100644
--- a/src/corelib/thread/qthread_win.cpp
+++ b/src/corelib/thread/qthread_win.cpp
@@ -37,12 +37,6 @@
 **
 ****************************************************************************/
 
-//#define WINVER 0x0500
-#if !defined(WINAPI_FAMILY) && (_WIN32_WINNT < 0x0400)
-#define _WIN32_WINNT 0x0400
-#endif
-
-
 #include "qthread.h"
 #include "qthread_p.h"
 #include "qthreadstorage.h"
diff --git a/src/corelib/thread/qwaitcondition_unix.cpp b/src/corelib/thread/qwaitcondition_unix.cpp
index 2a98fd28971..6adee5412ee 100644
--- a/src/corelib/thread/qwaitcondition_unix.cpp
+++ b/src/corelib/thread/qwaitcondition_unix.cpp
@@ -221,9 +221,12 @@ bool QWaitCondition::wait(QMutex *mutex, unsigned long time)
 
 bool QWaitCondition::wait(QReadWriteLock *readWriteLock, unsigned long time)
 {
-    if (!readWriteLock || readWriteLock->d->accessCount == 0)
+    if (!readWriteLock)
         return false;
-    if (readWriteLock->d->accessCount < -1) {
+    auto previousState = readWriteLock->stateForWaitCondition();
+    if (previousState == QReadWriteLock::Unlocked)
+        return false;
+    if (previousState == QReadWriteLock::RecursivelyLocked) {
         qWarning("QWaitCondition: cannot wait on QReadWriteLocks with recursive lockForWrite()");
         return false;
     }
@@ -231,12 +234,11 @@ bool QWaitCondition::wait(QReadWriteLock *readWriteLock, unsigned long time)
     report_error(pthread_mutex_lock(&d->mutex), "QWaitCondition::wait()", "mutex lock");
     ++d->waiters;
 
-    int previousAccessCount = readWriteLock->d->accessCount;
     readWriteLock->unlock();
 
     bool returnValue = d->wait(time);
 
-    if (previousAccessCount < 0)
+    if (previousState == QReadWriteLock::LockedForWrite)
         readWriteLock->lockForWrite();
     else
         readWriteLock->lockForRead();
diff --git a/src/corelib/thread/qwaitcondition_win.cpp b/src/corelib/thread/qwaitcondition_win.cpp
index 246e45a54ce..f3a645c5045 100644
--- a/src/corelib/thread/qwaitcondition_win.cpp
+++ b/src/corelib/thread/qwaitcondition_win.cpp
@@ -191,20 +191,22 @@ bool QWaitCondition::wait(QMutex *mutex, unsigned long time)
 
 bool QWaitCondition::wait(QReadWriteLock *readWriteLock, unsigned long time)
 {
-    if (!readWriteLock || readWriteLock->d->accessCount == 0)
+    if (!readWriteLock)
         return false;
-    if (readWriteLock->d->accessCount < -1) {
+    auto previousState = readWriteLock->stateForWaitCondition();
+    if (previousState == QReadWriteLock::Unlocked)
+        return false;
+    if (previousState == QReadWriteLock::RecursivelyLocked) {
         qWarning("QWaitCondition: cannot wait on QReadWriteLocks with recursive lockForWrite()");
         return false;
     }
 
     QWaitConditionEvent *wce = d->pre();
-    int previousAccessCount = readWriteLock->d->accessCount;
     readWriteLock->unlock();
 
     bool returnValue = d->wait(wce, time);
 
-    if (previousAccessCount < 0)
+    if (previousState == QReadWriteLock::LockedForWrite)
         readWriteLock->lockForWrite();
     else
         readWriteLock->lockForRead();
diff --git a/src/corelib/thread/thread.pri b/src/corelib/thread/thread.pri
index 2cb00a6cf44..0a989cfcaf7 100644
--- a/src/corelib/thread/thread.pri
+++ b/src/corelib/thread/thread.pri
@@ -43,24 +43,20 @@ SOURCES += thread/qatomic.cpp \
            thread/qthreadpool.cpp \
            thread/qthreadstorage.cpp
 
-unix:SOURCES += thread/qthread_unix.cpp \
-                         thread/qwaitcondition_unix.cpp
-
-win32:SOURCES += thread/qthread_win.cpp \
-		 thread/qwaitcondition_win.cpp
-
-integrity:SOURCES += thread/qthread_unix.cpp \
-		thread/qwaitcondition_unix.cpp
-
-false {
-    # files #included by others, but listed here so IDEs parsing this file know
-    # they are part of QtCore. Usually, qmake can find out that certain files
-    # are #included by others and thus remove from SOURCES, but it gets lost
-    # with qmutex.cpp.
+win32 {
     SOURCES += \
-        thread/qmutex_linux.cpp \
-        thread/qmutex_mac.cpp \
-        thread/qmutex_unix.cpp \
-        thread/qmutex_win.cpp
+        thread/qmutex_win.cpp \
+        thread/qthread_win.cpp \
+        thread/qwaitcondition_win.cpp
+} else {
+    darwin {
+        SOURCES += thread/qmutex_mac.cpp
+    } else: linux {
+        SOURCES += thread/qmutex_linux.cpp
+    } else {
+        SOURCES += thread/qmutex_unix.cpp
+    }
+    SOURCES += \
+        thread/qthread_unix.cpp \
+        thread/qwaitcondition_unix.cpp
 }
-
diff --git a/src/corelib/tools/qcollator_macx.cpp b/src/corelib/tools/qcollator_macx.cpp
index 207b5bb2b1b..b4d93e58d45 100644
--- a/src/corelib/tools/qcollator_macx.cpp
+++ b/src/corelib/tools/qcollator_macx.cpp
@@ -55,7 +55,7 @@ void QCollatorPrivate::init()
     LocaleRef localeRef;
     int rc = LocaleRefFromLocaleString(locale.bcp47Name().toLocal8Bit(), &localeRef);
     if (rc != 0)
-        qWarning() << "couldn't initialize the locale";
+        qWarning("couldn't initialize the locale");
 
     UInt32 options = 0;
 
@@ -73,7 +73,7 @@ void QCollatorPrivate::init()
         &collator
     );
     if (status != 0)
-        qWarning() << "Couldn't initialize the collator";
+        qWarning("Couldn't initialize the collator");
 
     dirty = false;
 }
diff --git a/src/corelib/tools/qcollator_win.cpp b/src/corelib/tools/qcollator_win.cpp
index 30e358c3f94..fcd8d069eb2 100644
--- a/src/corelib/tools/qcollator_win.cpp
+++ b/src/corelib/tools/qcollator_win.cpp
@@ -73,7 +73,7 @@ void QCollatorPrivate::init()
         if (QSysInfo::windowsVersion() >= QSysInfo::WV_WINDOWS7)
             collator |= SORT_DIGITSASNUMBERS;
         else
-            qWarning() << "Numeric sorting unsupported on Windows versions older than Windows 7.";
+            qWarning("Numeric sorting unsupported on Windows versions older than Windows 7.");
     }
 
     if (ignorePunctuation)
diff --git a/src/corelib/tools/qhash.cpp b/src/corelib/tools/qhash.cpp
index b49c9d683ab..8ab98bd5094 100644
--- a/src/corelib/tools/qhash.cpp
+++ b/src/corelib/tools/qhash.cpp
@@ -113,31 +113,31 @@ static uint crc32(const Char *ptr, size_t len, uint h)
 
     p += 8;
     for ( ; p <= e; p += 8)
-        h2 = _mm_crc32_u64(h2, *reinterpret_cast<const qlonglong *>(p - 8));
+        h2 = _mm_crc32_u64(h2, qUnalignedLoad<qlonglong>(p - 8));
     h = h2;
     p -= 8;
 
     len = e - p;
     if (len & 4) {
-        h = _mm_crc32_u32(h, *reinterpret_cast<const uint *>(p));
+        h = _mm_crc32_u32(h, qUnalignedLoad<uint>(p));
         p += 4;
     }
 #  else
     p += 4;
     for ( ; p <= e; p += 4)
-        h = _mm_crc32_u32(h, *reinterpret_cast<const uint *>(p - 4));
+        h = _mm_crc32_u32(h, qUnalignedLoad<uint>(p - 4));
     p -= 4;
     len = e - p;
 #  endif
     if (len & 2) {
-        h = _mm_crc32_u16(h, *reinterpret_cast<const ushort *>(p));
+        h = _mm_crc32_u16(h, qUnalignedLoad<ushort>(p));
         p += 2;
     }
     if (sizeof(Char) == 1 && len & 1)
         h = _mm_crc32_u8(h, *p);
     return h;
 }
-#elif defined(Q_PROCESSOR_ARM_V8)
+#elif defined(__ARM_FEATURE_CRC32)
 static inline bool hasFastCrc32()
 {
     return qCpuHasFeature(CRC32);
diff --git a/src/corelib/tools/qmap.h b/src/corelib/tools/qmap.h
index 7eec2819572..9801878bdc7 100644
--- a/src/corelib/tools/qmap.h
+++ b/src/corelib/tools/qmap.h
@@ -909,7 +909,7 @@ template <class Key, class T>
 void QMap<Key, T>::dump() const
 {
     const_iterator it = begin();
-    qDebug() << "map dump:";
+    qDebug("map dump:");
     while (it != end()) {
         const QMapNodeBase *n = it.i;
         int depth = 0;
@@ -922,7 +922,7 @@ void QMap<Key, T>::dump() const
                  << it.key() << it.value();
         ++it;
     }
-    qDebug() << "---------";
+    qDebug("---------");
 }
 #endif
 
diff --git a/src/corelib/tools/qrect.h b/src/corelib/tools/qrect.h
index 31fdc8ce6ba..b376b6b9997 100644
--- a/src/corelib/tools/qrect.h
+++ b/src/corelib/tools/qrect.h
@@ -252,7 +252,7 @@ Q_DECL_CONSTEXPR inline QPoint QRect::bottomLeft() const Q_DECL_NOTHROW
 { return QPoint(x1, y2); }
 
 Q_DECL_CONSTEXPR inline QPoint QRect::center() const Q_DECL_NOTHROW
-{ return QPoint((x1+x2)/2, (y1+y2)/2); }
+{ return QPoint(int((qint64(x1)+x2)/2), int((qint64(y1)+y2)/2)); } // cast avoids overflow on addition
 
 Q_DECL_CONSTEXPR inline int QRect::width() const Q_DECL_NOTHROW
 { return  x2 - x1 + 1; }
diff --git a/src/corelib/tools/qsimd.cpp b/src/corelib/tools/qsimd.cpp
index f2caaaa5384..9037442d9d5 100644
--- a/src/corelib/tools/qsimd.cpp
+++ b/src/corelib/tools/qsimd.cpp
@@ -117,13 +117,7 @@ static inline quint64 detectProcessorFeatures()
 {
     quint64 features = 0;
 
-#if defined(Q_OS_IOS)
-    features |= Q_UINT64_C(1) << CpuFeatureNEON; // On iOS, NEON is always available.
-#  ifdef Q_PROCESSOR_ARM_V8
-    features |= Q_UINT64_C(1) << CpuFeatureCRC32; // On iOS, crc32 is always available if the architecture is Aarch32/64.
-#  endif
-    return features;
-#elif defined(Q_OS_LINUX)
+#if defined(Q_OS_LINUX)
 #  if defined(Q_PROCESSOR_ARM_V8) && defined(Q_PROCESSOR_ARM_64)
     features |= Q_UINT64_C(1) << CpuFeatureNEON; // NEON is always available on ARMv8 64bit.
 #  endif
@@ -167,10 +161,10 @@ static inline quint64 detectProcessorFeatures()
 #endif
 
 #if defined(__ARM_NEON__)
-    features = Q_UINT64_C(1) << CpuFeatureNEON;
+    features |= Q_UINT64_C(1) << CpuFeatureNEON;
 #endif
 #if defined(__ARM_FEATURE_CRC32)
-    features = Q_UINT64_C(1) << CpuFeatureCRC32;
+    features |= Q_UINT64_C(1) << CpuFeatureCRC32;
 #endif
 
     return features;
@@ -753,4 +747,26 @@ void qDumpCPUFeatures()
     puts("");
 }
 
+/*!
+    \internal
+    \fn T qUnalignedLoad(const void *ptr)
+    \since 5.6.1
+
+    Loads a \c{T} from address \a ptr, which may be misaligned.
+
+    Use of this function avoid the undefined behavior that the C++ standard
+    otherwise attributes to unaligned loads.
+*/
+
+/*!
+    \internal
+    \fn void qUnalignedStore(void *ptr, T t)
+    \since 5.6.1
+
+    Stores \a t to address \a ptr, which may be misaligned.
+
+    Use of this function avoid the undefined behavior that the C++ standard
+    otherwise attributes to unaligned stores.
+*/
+
 QT_END_NAMESPACE
diff --git a/src/corelib/tools/qsimd_p.h b/src/corelib/tools/qsimd_p.h
index c7710374270..1a795a670df 100644
--- a/src/corelib/tools/qsimd_p.h
+++ b/src/corelib/tools/qsimd_p.h
@@ -267,6 +267,13 @@
 #  endif
 #endif
 
+// Clang compiler fix, see http://lists.llvm.org/pipermail/cfe-commits/Week-of-Mon-20160222/151168.html
+// This should be tweaked with an "upper version" of clang once we know which release fixes the
+// issue. At that point we can rely on __ARM_FEATURE_CRC32 again.
+#if defined(Q_CC_CLANG) && defined(Q_OS_DARWIN) && defined (__ARM_FEATURE_CRC32)
+#  undef __ARM_FEATURE_CRC32
+#endif
+
 // NEON intrinsics
 // note: as of GCC 4.9, does not support function targets for ARM
 #if defined(__ARM_NEON) || defined(__ARM_NEON__)
@@ -514,6 +521,32 @@ unsigned _bit_scan_forward(unsigned val)
 #define ALIGNMENT_PROLOGUE_16BYTES(ptr, i, length) \
     for (; i < static_cast<int>(qMin(static_cast<quintptr>(length), ((4 - ((reinterpret_cast<quintptr>(ptr) >> 2) & 0x3)) & 0x3))); ++i)
 
+template <typename T>
+Q_ALWAYS_INLINE
+T qUnalignedLoad(const void *ptr) Q_DECL_NOTHROW
+{
+    T result;
+#if QT_HAS_BUILTIN(__builtin_memcpy)
+    __builtin_memcpy
+#else
+    memcpy
+#endif
+    /*memcpy*/(&result, ptr, sizeof result);
+    return result;
+}
+
+template <typename T>
+Q_ALWAYS_INLINE
+void qUnalignedStore(void *ptr, T t) Q_DECL_NOTHROW
+{
+#if QT_HAS_BUILTIN(__builtin_memcpy)
+    __builtin_memcpy
+#else
+    memcpy
+#endif
+    /*memcpy*/(ptr, &t, sizeof t);
+}
+
 QT_END_NAMESPACE
 
 #endif // QSIMD_P_H
diff --git a/src/corelib/tools/qstring.cpp b/src/corelib/tools/qstring.cpp
index 18435c30091..5c6ce179d09 100644
--- a/src/corelib/tools/qstring.cpp
+++ b/src/corelib/tools/qstring.cpp
@@ -584,7 +584,7 @@ static int ucstrncmp(const QChar *a, const uchar *c, int l)
     // we'll read uc[offset..offset+7] (16 bytes) and c[offset..offset+7] (8 bytes)
     if (uc + offset + 7 < e) {
         // same, but we're using an 8-byte load
-        __m128i chunk = _mm_cvtsi64_si128(*(const long long *)(c + offset));
+        __m128i chunk = _mm_cvtsi64_si128(qUnalignedLoad<long long>(c + offset));
         __m128i secondHalf = _mm_unpacklo_epi8(chunk, nullmask);
 
         __m128i ucdata = _mm_loadu_si128((const __m128i*)(uc + offset));
@@ -6177,11 +6177,7 @@ QString QString::vasprintf(const char *cformat, va_list ap)
             }
             case 'p': {
                 void *arg = va_arg(ap, void*);
-#ifdef Q_OS_WIN64
-                quint64 i = reinterpret_cast<quint64>(arg);
-#else
-                quint64 i = reinterpret_cast<unsigned long>(arg);
-#endif
+                const quint64 i = reinterpret_cast<quintptr>(arg);
                 flags |= QLocaleData::Alternate;
                 subst = QLocaleData::c()->unsLongLongToString(i, precision, 16, width, flags);
                 ++c;
@@ -10681,7 +10677,7 @@ QString QString::toHtmlEscaped() const
 /*!
     \internal
  */
-void QAbstractConcatenable::appendLatin1To(const char *a, int len, QChar *out)
+void QAbstractConcatenable::appendLatin1To(const char *a, int len, QChar *out) Q_DECL_NOTHROW
 {
     qt_from_latin1(reinterpret_cast<ushort *>(out), a, uint(len));
 }
diff --git a/src/corelib/tools/qstringbuilder.cpp b/src/corelib/tools/qstringbuilder.cpp
index eba939a413e..de12de19cb5 100644
--- a/src/corelib/tools/qstringbuilder.cpp
+++ b/src/corelib/tools/qstringbuilder.cpp
@@ -39,6 +39,7 @@
 
 #include "qstringbuilder.h"
 #include <QtCore/qtextcodec.h>
+#include <private/qutfcodec_p.h>
 
 QT_BEGIN_NAMESPACE
 
@@ -107,29 +108,14 @@ QT_BEGIN_NAMESPACE
 /*!
     \internal
  */
-void QAbstractConcatenable::convertFromAscii(const char *a, int len, QChar *&out)
+void QAbstractConcatenable::convertFromAscii(const char *a, int len, QChar *&out) Q_DECL_NOTHROW
 {
-    if (len == -1) {
+    if (Q_UNLIKELY(len == -1)) {
         if (!a)
             return;
-        while (*a && uchar(*a) < 0x80U)
-            *out++ = QLatin1Char(*a++);
-        if (!*a)
-            return;
-    } else {
-        int i;
-        for (i = 0; i < len && uchar(a[i]) < 0x80U; ++i)
-            *out++ = QLatin1Char(a[i]);
-        if (i == len)
-            return;
-        a += i;
-        len -= i;
+        len = int(strlen(a));
     }
-
-    // we need to complement with UTF-8 appending
-    QString tmp = QString::fromUtf8(a, len);
-    memcpy(out, reinterpret_cast<const char *>(tmp.constData()), sizeof(QChar) * tmp.size());
-    out += tmp.size();
+    out = QUtf8::convertToUnicode(out, a, len);
 }
 
 QT_END_NAMESPACE
diff --git a/src/corelib/tools/qstringbuilder.h b/src/corelib/tools/qstringbuilder.h
index faf9eb4b4d8..8ce98cbd71e 100644
--- a/src/corelib/tools/qstringbuilder.h
+++ b/src/corelib/tools/qstringbuilder.h
@@ -58,12 +58,12 @@ QT_BEGIN_NAMESPACE
 struct Q_CORE_EXPORT QAbstractConcatenable
 {
 protected:
-    static void convertFromAscii(const char *a, int len, QChar *&out);
-    static inline void convertFromAscii(char a, QChar *&out)
+    static void convertFromAscii(const char *a, int len, QChar *&out) Q_DECL_NOTHROW;
+    static inline void convertFromAscii(char a, QChar *&out) Q_DECL_NOTHROW
     {
         *out++ = QLatin1Char(a);
     }
-    static void appendLatin1To(const char *a, int len, QChar *out);
+    static void appendLatin1To(const char *a, int len, QChar *out) Q_DECL_NOTHROW;
 };
 
 template <typename T> struct QConcatenable {};
diff --git a/src/corelib/tools/qtimeline.cpp b/src/corelib/tools/qtimeline.cpp
index dd6a4dbc561..adbc2900e39 100644
--- a/src/corelib/tools/qtimeline.cpp
+++ b/src/corelib/tools/qtimeline.cpp
@@ -131,7 +131,7 @@ void QTimeLinePrivate::setCurrentTime(int msecs)
         const int transitionframe = (direction == QTimeLine::Forward ? endFrame : startFrame);
         if (looping && !finished && transitionframe != currentFrame) {
 #ifdef QTIMELINE_DEBUG
-            qDebug() << "QTimeLinePrivate::setCurrentTime: transitionframe";
+            qDebug("QTimeLinePrivate::setCurrentTime: transitionframe");
 #endif
             emit q->frameChanged(transitionframe, QTimeLine::QPrivateSignal());
         }
diff --git a/src/corelib/tools/qtimezone.cpp b/src/corelib/tools/qtimezone.cpp
index 46722489459..3c7417d64e6 100644
--- a/src/corelib/tools/qtimezone.cpp
+++ b/src/corelib/tools/qtimezone.cpp
@@ -67,7 +67,7 @@ static QTimeZonePrivate *newBackendTimeZone()
 #elif defined Q_OS_UNIX
     return new QTzTimeZonePrivate();
     // Registry based timezone backend not available on WinRT
-#elif defined Q_OS_WIN && !defined Q_OS_WINRT
+#elif defined Q_OS_WIN
     return new QWinTimeZonePrivate();
 #elif defined QT_USE_ICU
     return new QIcuTimeZonePrivate();
@@ -94,7 +94,7 @@ static QTimeZonePrivate *newBackendTimeZone(const QByteArray &ianaId)
 #elif defined Q_OS_UNIX
     return new QTzTimeZonePrivate(ianaId);
     // Registry based timezone backend not available on WinRT
-#elif defined Q_OS_WIN && !defined Q_OS_WINRT
+#elif defined Q_OS_WIN
     return new QWinTimeZonePrivate(ianaId);
 #elif defined QT_USE_ICU
     return new QIcuTimeZonePrivate(ianaId);
diff --git a/src/corelib/tools/qtimezoneprivate_win.cpp b/src/corelib/tools/qtimezoneprivate_win.cpp
index 1d19f01b4e7..f84b66fa998 100644
--- a/src/corelib/tools/qtimezoneprivate_win.cpp
+++ b/src/corelib/tools/qtimezoneprivate_win.cpp
@@ -48,6 +48,10 @@
 
 QT_BEGIN_NAMESPACE
 
+#ifndef Q_OS_WINRT
+#define QT_USE_REGISTRY_TIMEZONE 1
+#endif
+
 /*
     Private
 
@@ -65,9 +69,10 @@ QT_BEGIN_NAMESPACE
 
 // Vista introduced support for historic data, see MSDN docs on DYNAMIC_TIME_ZONE_INFORMATION
 // http://msdn.microsoft.com/en-gb/library/windows/desktop/ms724253%28v=vs.85%29.aspx
-
+#ifdef QT_USE_REGISTRY_TIMEZONE
 static const char tzRegPath[] = "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones";
 static const char currTzRegPath[] = "SYSTEM\\CurrentControlSet\\Control\\TimeZoneInformation";
+#endif
 
 enum {
     MIN_YEAR = -292275056,
@@ -129,6 +134,7 @@ static bool equalTzi(const TIME_ZONE_INFORMATION &tzi1, const TIME_ZONE_INFORMAT
            && wcscmp(tzi1.DaylightName, tzi2.DaylightName) == 0);
 }
 
+#ifdef QT_USE_REGISTRY_TIMEZONE
 static bool openRegistryKey(const QString &keyPath, HKEY *key)
 {
     return (RegOpenKeyEx(HKEY_LOCAL_MACHINE, (const wchar_t*)keyPath.utf16(), 0, KEY_READ, key)
@@ -203,9 +209,61 @@ static TIME_ZONE_INFORMATION getRegistryTzi(const QByteArray &windowsId, bool *o
 
     return tzi;
 }
+#else // QT_USE_REGISTRY_TIMEZONE
+struct QWinDynamicTimeZone
+{
+    QString standardName;
+    QString daylightName;
+    QString timezoneName;
+    qint32 bias;
+    bool daylightTime;
+};
+
+typedef QHash<QByteArray, QWinDynamicTimeZone> QWinRTTimeZoneHash;
+
+Q_GLOBAL_STATIC(QWinRTTimeZoneHash, gTimeZones)
+
+static void enumerateTimeZones()
+{
+    DYNAMIC_TIME_ZONE_INFORMATION dtzInfo;
+    quint32 index = 0;
+    QString prevTimeZoneKeyName;
+    while (SUCCEEDED(EnumDynamicTimeZoneInformation(index++, &dtzInfo))) {
+        QWinDynamicTimeZone item;
+        item.timezoneName = QString::fromWCharArray(dtzInfo.TimeZoneKeyName);
+        // As soon as key name repeats, break. Some systems continue to always
+        // return the last item independent of index being out of range
+        if (item.timezoneName == prevTimeZoneKeyName)
+            break;
+        item.standardName = QString::fromWCharArray(dtzInfo.StandardName);
+        item.daylightName = QString::fromWCharArray(dtzInfo.DaylightName);
+        item.daylightTime = !dtzInfo.DynamicDaylightTimeDisabled;
+        item.bias = dtzInfo.Bias;
+        gTimeZones->insert(item.timezoneName.toUtf8(), item);
+        prevTimeZoneKeyName = item.timezoneName;
+    }
+}
+
+static DYNAMIC_TIME_ZONE_INFORMATION dynamicInfoForId(const QByteArray &windowsId)
+{
+    DYNAMIC_TIME_ZONE_INFORMATION dtzInfo;
+    quint32 index = 0;
+    QString prevTimeZoneKeyName;
+    while (SUCCEEDED(EnumDynamicTimeZoneInformation(index++, &dtzInfo))) {
+        const QString timeZoneName = QString::fromWCharArray(dtzInfo.TimeZoneKeyName);
+        if (timeZoneName == QLatin1String(windowsId))
+            break;
+        if (timeZoneName == prevTimeZoneKeyName)
+            break;
+        prevTimeZoneKeyName = timeZoneName;
+    }
+    return dtzInfo;
+}
+#endif // QT_USE_REGISTRY_TIMEZONE
 
 static QList<QByteArray> availableWindowsIds()
 {
+#ifdef QT_USE_REGISTRY_TIMEZONE
     // TODO Consider caching results in a global static, very unlikely to change.
     QList<QByteArray> list;
     HKEY key = NULL;
@@ -223,10 +281,16 @@ static QList<QByteArray> availableWindowsIds()
         RegCloseKey(key);
     }
     return list;
+#else // QT_USE_REGISTRY_TIMEZONE
+    if (gTimeZones->isEmpty())
+        enumerateTimeZones();
+    return gTimeZones->keys();
+#endif // QT_USE_REGISTRY_TIMEZONE
 }
 
 static QByteArray windowsSystemZoneId()
 {
+#ifdef QT_USE_REGISTRY_TIMEZONE
     // On Vista and later is held in the value TimeZoneKeyName in key currTzRegPath
     QString id;
     HKEY key = NULL;
@@ -248,6 +312,11 @@ static QByteArray windowsSystemZoneId()
         if (equalTzi(getRegistryTzi(winId, &ok), sysTzi))
             return winId;
     }
+#else // QT_USE_REGISTRY_TIMEZONE
+    DYNAMIC_TIME_ZONE_INFORMATION dtzi;
+    if (SUCCEEDED(GetDynamicTimeZoneInformation(&dtzi)))
+        return QString::fromWCharArray(dtzi.TimeZoneKeyName).toLocal8Bit();
+#endif // QT_USE_REGISTRY_TIMEZONE
 
     // If we can't determine the current ID use UTC
     return QTimeZonePrivate::utcQByteArray();
@@ -368,6 +437,7 @@ void QWinTimeZonePrivate::init(const QByteArray &ianaId)
     }
 
     if (!m_windowsId.isEmpty()) {
+#ifdef QT_USE_REGISTRY_TIMEZONE
         // Open the base TZI for the time zone
         HKEY baseKey = NULL;
         const QString baseKeyPath = QString::fromUtf8(tzRegPath) + QLatin1Char('\\')
@@ -404,6 +474,34 @@ void QWinTimeZonePrivate::init(const QByteArray &ianaId)
             }
             RegCloseKey(baseKey);
         }
+#else // QT_USE_REGISTRY_TIMEZONE
+        if (gTimeZones->isEmpty())
+            enumerateTimeZones();
+        QWinRTTimeZoneHash::const_iterator it = gTimeZones->find(m_windowsId);
+        if (it != gTimeZones->constEnd()) {
+            m_displayName = it->timezoneName;
+            m_standardName = it->standardName;
+            m_daylightName = it->daylightName;
+            DWORD firstYear = 0;
+            DWORD lastYear = 0;
+            DYNAMIC_TIME_ZONE_INFORMATION dtzi = dynamicInfoForId(m_windowsId);
+            GetDynamicTimeZoneInformationEffectiveYears(&dtzi, &firstYear, &lastYear);
+            // If there is no dynamic information, you can still query for
+            // year 0, which helps simplifying following part
+            for (DWORD year = firstYear; year <= lastYear; ++year) {
+                TIME_ZONE_INFORMATION tzi;
+                if (!GetTimeZoneInformationForYear(year, &dtzi, &tzi))
+                    continue;
+                QWinTransitionRule rule;
+                rule.standardTimeBias = tzi.Bias + tzi.StandardBias;
+                rule.daylightTimeBias = tzi.Bias + tzi.DaylightBias - rule.standardTimeBias;
+                rule.standardTimeRule = tzi.StandardDate;
+                rule.daylightTimeRule = tzi.DaylightDate;
+                rule.startYear = year;
+                m_tranRules.append(rule);
+            }
+        }
+#endif // QT_USE_REGISTRY_TIMEZONE
     }
 
     // If there are no rules then we failed to find a windowsId or any tzi info
diff --git a/src/corelib/tools/tools.pri b/src/corelib/tools/tools.pri
index b87f234f407..95a7ece67c8 100644
--- a/src/corelib/tools/tools.pri
+++ b/src/corelib/tools/tools.pri
@@ -144,9 +144,11 @@ else:unix {
     SOURCES += tools/qelapsedtimer_unix.cpp tools/qlocale_unix.cpp tools/qtimezoneprivate_tz.cpp
 }
 else:win32 {
-    SOURCES += tools/qelapsedtimer_win.cpp tools/qlocale_win.cpp
-    !winrt: SOURCES += tools/qtimezoneprivate_win.cpp
+    SOURCES += tools/qelapsedtimer_win.cpp \
+               tools/qlocale_win.cpp \
+               tools/qtimezoneprivate_win.cpp
     winphone: LIBS_PRIVATE += -lWindowsPhoneGlobalizationUtil
+    winrt-*-msvc2013: LIBS += advapi32.lib
 } else:integrity:SOURCES += tools/qelapsedtimer_unix.cpp tools/qlocale_unix.cpp
 else:SOURCES += tools/qelapsedtimer_generic.cpp
 
@@ -204,7 +206,7 @@ contains(QT_CONFIG, doubleconversion) {
 }
 
 # Note: libm should be present by default becaue this is C++
-!macx-icc:!vxworks:!haiku:unix:LIBS_PRIVATE += -lm
+unix:!macx-icc:!vxworks:!haiku:!integrity: LIBS_PRIVATE += -lm
 
 TR_EXCLUDE += ../3rdparty/*
 
diff --git a/src/dbus/dbus.pro b/src/dbus/dbus.pro
index ebeab5c1b09..4c1aec7bb37 100644
--- a/src/dbus/dbus.pro
+++ b/src/dbus/dbus.pro
@@ -25,8 +25,6 @@ win32 {
 
 QMAKE_DOCS = $$PWD/doc/qtdbus.qdocconf
 
-load(qt_module)
-
 PUB_HEADERS = qdbusargument.h \
     qdbusconnectioninterface.h \
     qdbusmacros.h \
@@ -91,3 +89,5 @@ SOURCES += qdbusconnection.cpp \
     qdbusservicewatcher.cpp \
     qdbusunixfiledescriptor.cpp \
     qdbusvirtualobject.cpp
+
+load(qt_module)
diff --git a/src/dbus/qdbusconnection.cpp b/src/dbus/qdbusconnection.cpp
index 3f2e80cdacf..ea8c2b03110 100644
--- a/src/dbus/qdbusconnection.cpp
+++ b/src/dbus/qdbusconnection.cpp
@@ -214,7 +214,7 @@ QDBusConnectionPrivate *QDBusConnectionManager::connectToBus(QDBusConnection::Bu
     data.suspendedDelivery = suspendedDelivery;
 
     emit connectionRequested(&data);
-    if (suspendedDelivery) {
+    if (suspendedDelivery && data.result->connection) {
         data.result->ref.ref();
         QDBusConnectionDispatchEnabler *o = new QDBusConnectionDispatchEnabler(data.result);
         QTimer::singleShot(0, o, SLOT(execute()));
@@ -297,7 +297,7 @@ void QDBusConnectionManager::executeConnectionRequest(QDBusConnectionManager::Co
         // will lock in QDBusConnectionPrivate::connectRelay()
         d->setConnection(c, error);
         d->createBusService();
-        if (data->suspendedDelivery)
+        if (c && data->suspendedDelivery)
             d->setDispatchEnabled(false);
     }
 }
diff --git a/src/dbus/qdbusintegrator.cpp b/src/dbus/qdbusintegrator.cpp
index 25678a56a98..105714ee64c 100644
--- a/src/dbus/qdbusintegrator.cpp
+++ b/src/dbus/qdbusintegrator.cpp
@@ -486,6 +486,11 @@ QDBusSpyCallEvent::~QDBusSpyCallEvent()
 }
 
 void QDBusSpyCallEvent::placeMetaCall(QObject *)
+{
+    invokeSpyHooks(msg, hooks, hookCount);
+}
+
+inline void QDBusSpyCallEvent::invokeSpyHooks(const QDBusMessage &msg, const Hook *hooks, int hookCount)
 {
     // call the spy hook list
     for (int i = 0; i < hookCount; ++i)
@@ -515,7 +520,12 @@ bool QDBusConnectionPrivate::handleMessage(const QDBusMessage &amsg)
 {
     if (!ref.load())
         return false;
-    if (!dispatchEnabled && !QDBusMessagePrivate::isLocal(amsg)) {
+
+    // local message are always delivered, regardless of filtering
+    // or whether the dispatcher is enabled
+    bool isLocal = QDBusMessagePrivate::isLocal(amsg);
+
+    if (!dispatchEnabled && !isLocal) {
         // queue messages only, we'll handle them later
         qDBusDebug() << this << "delivery is suspended";
         pendingMessages << amsg;
@@ -529,13 +539,23 @@ bool QDBusConnectionPrivate::handleMessage(const QDBusMessage &amsg)
         // let them see the signal too
         return false;
     case QDBusMessage::MethodCallMessage:
-        // run it through the spy filters (if any) before the regular processing
+        // run it through the spy filters (if any) before the regular processing:
+        // a) if it's a local message, we're in the caller's thread, so invoke the filter directly
+        // b) if it's an external message, post to the main thread
         if (Q_UNLIKELY(qDBusSpyHookList.exists()) && qApp) {
             const QDBusSpyHookList &list = *qDBusSpyHookList;
-            qDBusDebug() << this << "invoking message spies";
-            QCoreApplication::postEvent(qApp, new QDBusSpyCallEvent(this, QDBusConnection(this),
-                                                                    amsg, list.constData(), list.size()));
-            return true;
+            if (isLocal) {
+                Q_ASSERT(QThread::currentThread() != thread());
+                qDBusDebug() << this << "invoking message spies directly";
+                QDBusSpyCallEvent::invokeSpyHooks(amsg, list.constData(), list.size());
+            } else {
+                qDBusDebug() << this << "invoking message spies via event";
+                QCoreApplication::postEvent(qApp, new QDBusSpyCallEvent(this, QDBusConnection(this),
+                                                                        amsg, list.constData(), list.size()));
+
+                // we'll be called back, so return
+                return true;
+            }
         }
 
         handleObjectCall(amsg);
@@ -1456,9 +1476,9 @@ void QDBusConnectionPrivate::handleObjectCall(const QDBusMessage &msg)
     // that means the dispatchLock mutex is locked
     // must not call out to user code in that case
     //
-    // however, if the message is internal, handleMessage was called
-    // directly and no lock is in place. We can therefore call out to
-    // user code, if necessary
+    // however, if the message is internal, handleMessage was called directly
+    // (user's thread) and no lock is in place. We can therefore call out to
+    // user code, if necessary.
     ObjectTreeNode result;
     int usedLength;
     QThread *objThread = 0;
@@ -1497,12 +1517,14 @@ void QDBusConnectionPrivate::handleObjectCall(const QDBusMessage &msg)
                                                            usedLength, msg));
             return;
         } else if (objThread != QThread::currentThread()) {
-            // synchronize with other thread
+            // looped-back message, targeting another thread:
+            // synchronize with it
             postEventToThread(HandleObjectCallPostEventAction, result.obj,
                               new QDBusActivateObjectEvent(QDBusConnection(this), this, result,
                                                            usedLength, msg, &sem));
             semWait = true;
         } else {
+            // looped-back message, targeting current thread
             semWait = false;
         }
     } // release the lock
@@ -1796,7 +1818,7 @@ void QDBusConnectionPrivate::processFinishedCall(QDBusPendingCallPrivate *call)
         if (e)
             connection->postEventToThread(MessageResultReceivedAction, call->receiver, e);
         else
-            qDBusDebug() << "Deliver failed!";
+            qDBusDebug("Deliver failed!");
     }
 
     if (call->pending) {
diff --git a/src/dbus/qdbusintegrator_p.h b/src/dbus/qdbusintegrator_p.h
index 89043148e3b..470baeb6927 100644
--- a/src/dbus/qdbusintegrator_p.h
+++ b/src/dbus/qdbusintegrator_p.h
@@ -151,6 +151,7 @@ public:
     {}
     ~QDBusSpyCallEvent();
     void placeMetaCall(QObject *) Q_DECL_OVERRIDE;
+    static inline void invokeSpyHooks(const QDBusMessage &msg, const Hook *hooks, int hookCount);
 
     QDBusConnection conn;   // keeps the refcount in QDBusConnectionPrivate up
     QDBusMessage msg;
diff --git a/src/gui/doc/snippets/code/src_gui_kernel_qguiapplication.cpp b/src/gui/doc/snippets/code/src_gui_kernel_qguiapplication.cpp
index 4ddf8c8acbe..63fdb3bdd03 100644
--- a/src/gui/doc/snippets/code/src_gui_kernel_qguiapplication.cpp
+++ b/src/gui/doc/snippets/code/src_gui_kernel_qguiapplication.cpp
@@ -53,6 +53,7 @@ int main(int argc, char *argv[])
 MyMainWidget::MyMainWidget(QWidget *parent)
     :QWidget(parent)
 {
+    QGuiApplication::setFallbackSessionManagementEnabled(false);
     connect(qApp, SIGNAL(commitDataRequest(QSessionManager)), SLOT(commitData(QSessionManager)));
 }
 
diff --git a/src/gui/gui.pro b/src/gui/gui.pro
index 55837bcf3b3..462f133ff8e 100644
--- a/src/gui/gui.pro
+++ b/src/gui/gui.pro
@@ -23,8 +23,6 @@ win32:contains(QT_CONFIG, angle)|contains(QT_CONFIG, dynamicgl) {
         \$\$QT_MODULE_INCLUDE_BASE/QtANGLE
 }
 
-load(qt_module)
-
 # Code coverage with TestCocoon
 # The following is required as extra compilers use $$QMAKE_CXX instead of $(CXX).
 # Without this, testcocoon.prf is read only after $$QMAKE_CXX is used by the
@@ -50,6 +48,7 @@ include(itemmodels/itemmodels.pri)
 
 QMAKE_LIBS += $$QMAKE_LIBS_GUI
 
+load(qt_module)
 load(cmake_functions)
 
 win32: CMAKE_WINDOWS_BUILD = True
diff --git a/src/gui/image/qicon_p.h b/src/gui/image/qicon_p.h
index 1df91edeb6e..cfae9b3e52e 100644
--- a/src/gui/image/qicon_p.h
+++ b/src/gui/image/qicon_p.h
@@ -96,6 +96,7 @@ struct QPixmapIconEngineEntry
     QIcon::State state;
     bool isNull() const {return (fileName.isEmpty() && pixmap.isNull()); }
 };
+Q_DECLARE_TYPEINFO(QPixmapIconEngineEntry, Q_MOVABLE_TYPE);
 
 inline QPixmapIconEngineEntry::QPixmapIconEngineEntry(const QString &file, const QImage &image, QIcon::Mode m, QIcon::State s)
     : fileName(file), size(image.size()), mode(m), state(s)
diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp
index 37b7b185222..f902f1b715d 100644
--- a/src/gui/image/qimage.cpp
+++ b/src/gui/image/qimage.cpp
@@ -4416,7 +4416,8 @@ QImage QImage::smoothScaled(int w, int h) const {
             src = src.convertToFormat(QImage::Format_RGB32);
     }
     src = qSmoothScaleImage(src, w, h);
-    copyMetadata(src.d, d);
+    if (!src.isNull())
+        copyMetadata(src.d, d);
     return src;
 }
 
diff --git a/src/gui/image/qimagereader.cpp b/src/gui/image/qimagereader.cpp
index db5fb003613..4dada4ca821 100644
--- a/src/gui/image/qimagereader.cpp
+++ b/src/gui/image/qimagereader.cpp
@@ -505,7 +505,7 @@ static QImageIOHandler *createReadHandlerHelper(QIODevice *device,
 
     if (!handler) {
 #ifdef QIMAGEREADER_DEBUG
-        qDebug() << "QImageReader::createReadHandler: no handlers found. giving up.";
+        qDebug("QImageReader::createReadHandler: no handlers found. giving up.");
 #endif
         // no handler: give up.
         return 0;
diff --git a/src/gui/image/qpaintengine_pic.cpp b/src/gui/image/qpaintengine_pic.cpp
index cf186892d59..6a87a01a878 100644
--- a/src/gui/image/qpaintengine_pic.cpp
+++ b/src/gui/image/qpaintengine_pic.cpp
@@ -91,7 +91,7 @@ bool QPicturePaintEngine::begin(QPaintDevice *pd)
 {
     Q_D(QPicturePaintEngine);
 #ifdef QT_PICTURE_DEBUG
-    qDebug() << "QPicturePaintEngine::begin()";
+    qDebug("QPicturePaintEngine::begin()");
 #endif
     Q_ASSERT(pd);
     QPicture *pic = static_cast<QPicture *>(pd);
@@ -124,7 +124,7 @@ bool QPicturePaintEngine::end()
 {
     Q_D(QPicturePaintEngine);
 #ifdef QT_PICTURE_DEBUG
-    qDebug() << "QPicturePaintEngine::end()";
+    qDebug("QPicturePaintEngine::end()");
 #endif
     d->pic_d->trecs++;
     d->s << (quint8) QPicturePrivate::PdcEnd << (quint8) 0;
diff --git a/src/gui/itemmodels/qstandarditemmodel.cpp b/src/gui/itemmodels/qstandarditemmodel.cpp
index 9b0c6163b40..6f30f0ea258 100644
--- a/src/gui/itemmodels/qstandarditemmodel.cpp
+++ b/src/gui/itemmodels/qstandarditemmodel.cpp
@@ -3009,7 +3009,7 @@ QMimeData *QStandardItemModel::mimeData(const QModelIndexList &indexes) const
             itemsSet << item;
             stack.push(item);
         } else {
-            qWarning() << "QStandardItemModel::mimeData: No item associated with invalid index";
+            qWarning("QStandardItemModel::mimeData: No item associated with invalid index");
             return 0;
         }
     }
diff --git a/src/gui/itemmodels/qstandarditemmodel_p.h b/src/gui/itemmodels/qstandarditemmodel_p.h
index 6ef7bfb412a..1849e1a8500 100644
--- a/src/gui/itemmodels/qstandarditemmodel_p.h
+++ b/src/gui/itemmodels/qstandarditemmodel_p.h
@@ -72,6 +72,7 @@ public:
     QVariant value;
     inline bool operator==(const QStandardItemData &other) const { return role == other.role && value == other.value; }
 };
+Q_DECLARE_TYPEINFO(QStandardItemData, Q_MOVABLE_TYPE);
 
 #ifndef QT_NO_DATASTREAM
 
diff --git a/src/gui/kernel/qcursor.h b/src/gui/kernel/qcursor.h
index 1b11bad69f9..814e8ab7bdc 100644
--- a/src/gui/kernel/qcursor.h
+++ b/src/gui/kernel/qcursor.h
@@ -87,9 +87,12 @@ public:
     QCursor &operator=(const QCursor &cursor);
 #ifdef Q_COMPILER_RVALUE_REFS
     QCursor(QCursor &&other) Q_DECL_NOTHROW : d(other.d) { other.d = Q_NULLPTR; }
-    inline QCursor &operator=(QCursor &&other)
-    { qSwap(d, other.d); return *this; }
+    inline QCursor &operator=(QCursor &&other) Q_DECL_NOTHROW
+    { swap(other); return *this; }
 #endif
+
+    void swap(QCursor &other) Q_DECL_NOTHROW { qSwap(d, other.d); }
+
     operator QVariant() const;
 
     Qt::CursorShape shape() const;
@@ -110,6 +113,7 @@ public:
 private:
     QCursorData *d;
 };
+Q_DECLARE_SHARED_NOT_MOVABLE_UNTIL_QT6(QCursor)
 
 /*****************************************************************************
   QCursor stream functions
diff --git a/src/gui/kernel/qevent.cpp b/src/gui/kernel/qevent.cpp
index 34387d95d88..2b3b1535378 100644
--- a/src/gui/kernel/qevent.cpp
+++ b/src/gui/kernel/qevent.cpp
@@ -701,6 +701,31 @@ QHoverEvent::~QHoverEvent()
     \sa Qt::MouseEventSource
 */
 
+/*!
+    \fn bool QWheelEvent::inverted() const
+    \since 5.7
+
+    Returns whether the delta values delivered with the event are inverted.
+
+    Normally, a vertical wheel will produce a QWheelEvent with positive delta
+    values if the top of the wheel is rotating away from the hand operating it.
+    Similarly, a horizontal wheel movement will produce a QWheelEvent with
+    positive delta values if the top of the wheel is moved to the left.
+
+    However, on some platforms this is configurable, so that the same
+    operations described above will produce negative delta values (but with the
+    same magnitude). With the inverted property a wheel event consumer can
+    choose to always follow the direction of the wheel, regardless of the
+    system settings, but only for specific widgets. (One such use case could be
+    that the user is rotating the wheel in the same direction as a visual
+    Tumbler rotates. Another usecase is to make a slider handle follow the
+    direction of movement of fingers on a touchpad regardless of system
+    configuration.)
+
+    \note Many platforms provide no such information. On such platforms
+    \l inverted always returns false.
+*/
+
 /*!
     \fn Qt::Orientation QWheelEvent::orientation() const
     \obsolete
@@ -734,7 +759,7 @@ QWheelEvent::QWheelEvent(const QPointF &pos, int delta,
                          Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers,
                          Qt::Orientation orient)
     : QInputEvent(Wheel, modifiers), p(pos), qt4D(delta), qt4O(orient), mouseState(buttons),
-      ph(Qt::NoScrollPhase), src(Qt::MouseEventNotSynthesized)
+      ph(Qt::NoScrollPhase), src(Qt::MouseEventNotSynthesized), invertedScrolling(false)
 {
     g = QCursor::pos();
     if (orient == Qt::Vertical)
@@ -769,7 +794,7 @@ QWheelEvent::QWheelEvent(const QPointF &pos, const QPointF& globalPos, int delta
                          Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers,
                          Qt::Orientation orient)
     : QInputEvent(Wheel, modifiers), p(pos), g(globalPos), qt4D(delta), qt4O(orient), mouseState(buttons),
-      ph(Qt::NoScrollPhase), src(Qt::MouseEventNotSynthesized)
+      ph(Qt::NoScrollPhase), src(Qt::MouseEventNotSynthesized), invertedScrolling(false)
 {
     if (orient == Qt::Vertical)
         angleD = QPoint(0, delta);
@@ -806,7 +831,7 @@ QWheelEvent::QWheelEvent(const QPointF &pos, const QPointF& globalPos,
             Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers)
     : QInputEvent(Wheel, modifiers), p(pos), g(globalPos), pixelD(pixelDelta),
       angleD(angleDelta), qt4D(qt4Delta), qt4O(qt4Orientation), mouseState(buttons), ph(Qt::NoScrollPhase),
-      src(Qt::MouseEventNotSynthesized)
+      src(Qt::MouseEventNotSynthesized), invertedScrolling(false)
 {}
 
 /*!
@@ -837,15 +862,14 @@ QWheelEvent::QWheelEvent(const QPointF &pos, const QPointF& globalPos,
             Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase)
     : QInputEvent(Wheel, modifiers), p(pos), g(globalPos), pixelD(pixelDelta),
       angleD(angleDelta), qt4D(qt4Delta), qt4O(qt4Orientation), mouseState(buttons), ph(phase),
-      src(Qt::MouseEventNotSynthesized)
+      src(Qt::MouseEventNotSynthesized), invertedScrolling(false)
 {}
 
 /*!
     Constructs a wheel event object.
 
-    The \a pos provides the location of the mouse cursor
-    within the window. The position in global coordinates is specified
-    by \a globalPos.
+    The \a pos provides the location of the mouse cursor within the window. The
+    position in global coordinates is specified by \a globalPos.
 
     \a pixelDelta contains the scrolling distance in pixels on screen, while
     \a angleDelta contains the wheel rotation distance. \a pixelDelta is
@@ -873,7 +897,49 @@ QWheelEvent::QWheelEvent(const QPointF &pos, const QPointF& globalPos,
             QPoint pixelDelta, QPoint angleDelta, int qt4Delta, Qt::Orientation qt4Orientation,
             Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase, Qt::MouseEventSource source)
     : QInputEvent(Wheel, modifiers), p(pos), g(globalPos), pixelD(pixelDelta),
-      angleD(angleDelta), qt4D(qt4Delta), qt4O(qt4Orientation), mouseState(buttons), ph(phase), src(source)
+      angleD(angleDelta), qt4D(qt4Delta), qt4O(qt4Orientation), mouseState(buttons), ph(phase), src(source),
+      invertedScrolling(false)
+{}
+
+/*!
+    Constructs a wheel event object.
+
+    The \a pos provides the location of the mouse cursor
+    within the window. The position in global coordinates is specified
+    by \a globalPos.
+
+    \a pixelDelta contains the scrolling distance in pixels on screen, while
+    \a angleDelta contains the wheel rotation distance. \a pixelDelta is
+    optional and can be null.
+
+    The mouse and keyboard states at the time of the event are specified by
+    \a buttons and \a modifiers.
+
+    For backwards compatibility, the event can also hold monodirectional wheel
+    event data: \a qt4Delta specifies the rotation, and \a qt4Orientation the
+    direction.
+
+    The scrolling phase of the event is specified by \a phase.
+
+    If the wheel event comes from a physical mouse wheel, \a source is set to
+    Qt::MouseEventNotSynthesized. If it comes from a gesture detected by the
+    operating system, or from a non-mouse hardware device, such that \a
+    pixelDelta is directly related to finger movement, \a source is set to
+    Qt::MouseEventSynthesizedBySystem. If it comes from Qt, source would be set
+    to Qt::MouseEventSynthesizedByQt.
+
+    If the system is configured to invert the delta values delivered with the
+    event (such as natural scrolling of the touchpad on OS X), \a inverted
+    should be \c true. Otherwise, \a inverted is \c false
+
+    \sa posF(), globalPosF(), angleDelta(), pixelDelta(), phase()
+*/
+QWheelEvent::QWheelEvent(const QPointF &pos, const QPointF& globalPos,
+            QPoint pixelDelta, QPoint angleDelta, int qt4Delta, Qt::Orientation qt4Orientation,
+            Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase, Qt::MouseEventSource source, bool inverted)
+    : QInputEvent(Wheel, modifiers), p(pos), g(globalPos), pixelD(pixelDelta),
+      angleD(angleDelta), qt4D(qt4Delta), qt4O(qt4Orientation), mouseState(buttons), ph(phase), src(source),
+      invertedScrolling(inverted)
 {}
 
 #endif // QT_NO_WHEELEVENT
diff --git a/src/gui/kernel/qevent.h b/src/gui/kernel/qevent.h
index 2f31566b23a..1c42c61e853 100644
--- a/src/gui/kernel/qevent.h
+++ b/src/gui/kernel/qevent.h
@@ -187,6 +187,9 @@ public:
     QWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta,
                 int qt4Delta, Qt::Orientation qt4Orientation, Qt::MouseButtons buttons,
                 Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase, Qt::MouseEventSource source);
+    QWheelEvent(const QPointF &pos, const QPointF &globalPos, QPoint pixelDelta, QPoint angleDelta,
+                int qt4Delta, Qt::Orientation qt4Orientation, Qt::MouseButtons buttons,
+                Qt::KeyboardModifiers modifiers, Qt::ScrollPhase phase, Qt::MouseEventSource source, bool inverted);
     ~QWheelEvent();
 
 
@@ -210,6 +213,7 @@ public:
     inline Qt::MouseButtons buttons() const { return mouseState; }
 
     inline Qt::ScrollPhase phase() const { return Qt::ScrollPhase(ph); }
+    inline bool inverted() const { return invertedScrolling; }
 
     Qt::MouseEventSource source() const { return Qt::MouseEventSource(src); }
 
@@ -223,7 +227,8 @@ protected:
     Qt::MouseButtons mouseState;
     uint ph : 2;
     uint src: 2;
-    int reserved : 28;
+    bool invertedScrolling : 1;
+    int reserved : 27;
 
     friend class QApplication;
 };
@@ -576,8 +581,10 @@ private:
         Qt::InputMethodQuery query;
         QVariant value;
     };
+    friend QTypeInfo<QueryPair>;
     QVector<QueryPair> m_values;
 };
+Q_DECLARE_TYPEINFO(QInputMethodQueryEvent::QueryPair, Q_MOVABLE_TYPE);
 
 #endif // QT_NO_INPUTMETHOD
 
diff --git a/src/gui/kernel/qguiapplication.cpp b/src/gui/kernel/qguiapplication.cpp
index e4d7ad8fcd7..31b30c6e5a2 100644
--- a/src/gui/kernel/qguiapplication.cpp
+++ b/src/gui/kernel/qguiapplication.cpp
@@ -146,6 +146,10 @@ QPlatformTheme *QGuiApplicationPrivate::platform_theme = 0;
 
 QList<QObject *> QGuiApplicationPrivate::generic_plugin_list;
 
+#ifndef QT_NO_SESSIONMANAGER
+bool QGuiApplicationPrivate::is_fallback_session_management_enabled = true;
+#endif
+
 enum ApplicationResourceFlags
 {
     ApplicationPaletteExplicitlySet = 0x1,
@@ -583,7 +587,7 @@ QGuiApplication::QGuiApplication(int &argc, char **argv, int flags)
 QGuiApplication::QGuiApplication(QGuiApplicationPrivate &p)
     : QCoreApplication(p)
 {
-    d_func()->init(); }
+}
 
 /*!
     Destructs the application.
@@ -1296,6 +1300,8 @@ void QGuiApplicationPrivate::eventDispatcherReady()
 
 void QGuiApplicationPrivate::init()
 {
+    QCoreApplicationPrivate::init();
+
     QCoreApplicationPrivate::is_app_running = false; // Starting up.
 
     bool loadTestability = false;
@@ -1437,7 +1443,7 @@ void QGuiApplicationPrivate::init()
             typedef void (*TasInitialize)(void);
             TasInitialize initFunction = (TasInitialize)testLib.resolve("qt_testability_init");
             if (Q_UNLIKELY(!initFunction)) {
-                qCritical() << "Library qttestability resolve failed!";
+                qCritical("Library qttestability resolve failed!");
             } else {
                 initFunction();
             }
@@ -1595,7 +1601,7 @@ QFunctionPointer QGuiApplication::platformFunction(const QByteArray &function)
 {
     QPlatformIntegration *pi = QGuiApplicationPrivate::platformIntegration();
     if (!pi) {
-        qWarning() << "QGuiApplication::platformFunction(): Must construct a QGuiApplication before accessing a platform function";
+        qWarning("QGuiApplication::platformFunction(): Must construct a QGuiApplication before accessing a platform function");
         return Q_NULLPTR;
     }
 
@@ -1974,7 +1980,8 @@ void QGuiApplicationPrivate::processWheelEvent(QWindowSystemInterfacePrivate::Wh
         return;
     }
 
-     QWheelEvent ev(localPoint, globalPoint, e->pixelDelta, e->angleDelta, e->qt4Delta, e->qt4Orientation, buttons, e->modifiers, e->phase, e->source);
+     QWheelEvent ev(localPoint, globalPoint, e->pixelDelta, e->angleDelta, e->qt4Delta, e->qt4Orientation,
+                    buttons, e->modifiers, e->phase, e->source, e->inverted);
      ev.setTimestamp(e->timestamp);
      QGuiApplication::sendSpontaneousEvent(window, &ev);
 #endif /* ifndef QT_NO_WHEELEVENT */
@@ -3136,6 +3143,57 @@ void QGuiApplicationPrivate::setApplicationState(Qt::ApplicationState state, boo
     emit qApp->applicationStateChanged(applicationState);
 }
 
+#ifndef QT_NO_SESSIONMANAGER
+// ### Qt6: consider removing the feature or making it less intrusive
+/*!
+    \since 5.6
+
+    Returns whether QGuiApplication will use fallback session management.
+
+    The default is \c true.
+
+    If this is \c true and the session manager allows user interaction,
+    QGuiApplication will try to close toplevel windows after
+    commitDataRequest() has been emitted. If a window cannot be closed, session
+    shutdown will be canceled and the application will keep running.
+
+    Fallback session management only benefits applications that have an
+    "are you sure you want to close this window?" feature or other logic that
+    prevents closing a toplevel window depending on certain conditions, and
+    that do nothing to explicitly implement session management. In applications
+    that \e do implement session management using the proper session management
+    API, fallback session management interferes and may break session
+    management logic.
+
+    \warning If all windows \e are closed due to fallback session management
+    and quitOnLastWindowClosed() is \c true, the application will quit before
+    it is explicitly instructed to quit through the platform's session
+    management protocol. That violation of protocol may prevent the platform
+    session manager from saving application state.
+
+    \sa setFallbackSessionManagementEnabled(),
+    QSessionManager::allowsInteraction(), saveStateRequest(),
+    commitDataRequest(), {Session Management}
+*/
+bool QGuiApplication::isFallbackSessionManagementEnabled()
+{
+    return QGuiApplicationPrivate::is_fallback_session_management_enabled;
+}
+
+/*!
+   \since 5.6
+
+    Sets whether QGuiApplication will use fallback session management to
+    \a enabled.
+
+    \sa isFallbackSessionManagementEnabled()
+*/
+void QGuiApplication::setFallbackSessionManagementEnabled(bool enabled)
+{
+    QGuiApplicationPrivate::is_fallback_session_management_enabled = enabled;
+}
+#endif // QT_NO_SESSIONMANAGER
+
 /*!
     \since 4.2
     \fn void QGuiApplication::commitDataRequest(QSessionManager &manager)
@@ -3160,7 +3218,8 @@ void QGuiApplicationPrivate::setApplicationState(Qt::ApplicationState state, boo
 
     \note You should use Qt::DirectConnection when connecting to this signal.
 
-    \sa isSessionRestored(), sessionId(), saveStateRequest(), {Session Management}
+    \sa setFallbackSessionManagementEnabled(), isSessionRestored(),
+    sessionId(), saveStateRequest(), {Session Management}
 */
 
 /*!
@@ -3290,9 +3349,13 @@ void QGuiApplicationPrivate::commitData()
 {
     Q_Q(QGuiApplication);
     is_saving_session = true;
+
     emit q->commitDataRequest(*session_manager);
-    if (session_manager->allowsInteraction() && !tryCloseAllWindows())
+    if (is_fallback_session_management_enabled && session_manager->allowsInteraction()
+        && !tryCloseAllWindows()) {
         session_manager->cancel();
+    }
+
     is_saving_session = false;
 }
 
diff --git a/src/gui/kernel/qguiapplication.h b/src/gui/kernel/qguiapplication.h
index 95e1b858092..10057c5b7f0 100644
--- a/src/gui/kernel/qguiapplication.h
+++ b/src/gui/kernel/qguiapplication.h
@@ -162,6 +162,9 @@ public:
     QString sessionId() const;
     QString sessionKey() const;
     bool isSavingSession() const;
+
+    static bool isFallbackSessionManagementEnabled();
+    static void setFallbackSessionManagementEnabled(bool);
 #endif
 
     static void sync();
diff --git a/src/gui/kernel/qguiapplication_p.h b/src/gui/kernel/qguiapplication_p.h
index e7c05015217..a028441a2f4 100644
--- a/src/gui/kernel/qguiapplication_p.h
+++ b/src/gui/kernel/qguiapplication_p.h
@@ -81,6 +81,8 @@ public:
     QGuiApplicationPrivate(int &argc, char **argv, int flags);
     ~QGuiApplicationPrivate();
 
+    void init();
+
     void createPlatformIntegration();
     void createEventDispatcher() Q_DECL_OVERRIDE;
     void eventDispatcherReady() Q_DECL_OVERRIDE;
@@ -248,6 +250,7 @@ public:
 #endif
 
 #ifndef QT_NO_SESSIONMANAGER
+    static bool is_fallback_session_management_enabled;
     QSessionManager *session_manager;
     bool is_session_restored;
     bool is_saving_session;
@@ -309,8 +312,6 @@ protected:
 private:
     friend class QDragManager;
 
-    void init();
-
     static QGuiApplicationPrivate *self;
     static QTouchDevice *m_fakeTouchDevice;
     static int m_fakeMouseSourcePointId;
diff --git a/src/gui/kernel/qhighdpiscaling_p.h b/src/gui/kernel/qhighdpiscaling_p.h
index a871fe00248..e790e3094fb 100644
--- a/src/gui/kernel/qhighdpiscaling_p.h
+++ b/src/gui/kernel/qhighdpiscaling_p.h
@@ -472,8 +472,9 @@ QVector<T> fromNativePixels(const QVector<T> &pixelValues, const QWindow *window
 
     QVector<T> pointValues;
     pointValues.reserve(pixelValues.size());
+    const auto factor = QHighDpiScaling::factor(window);
     for (const T &pixelValue : pixelValues)
-        pointValues.append(pixelValue / QHighDpiScaling::factor(window));
+        pointValues.append(pixelValue / factor);
     return pointValues;
 }
 
@@ -486,8 +487,9 @@ QVector<T> toNativePixels(const QVector<T> &pointValues, const QWindow *window)
 
     QVector<T> pixelValues;
     pixelValues.reserve(pointValues.size());
+    const auto factor = QHighDpiScaling::factor(window);
     for (const T &pointValue : pointValues)
-        pixelValues.append(pointValue * QHighDpiScaling::factor(window));
+        pixelValues.append(pointValue * factor);
     return pixelValues;
 }
 
diff --git a/src/gui/kernel/qopenglcontext.cpp b/src/gui/kernel/qopenglcontext.cpp
index b45396ab3cc..81c0971ea08 100644
--- a/src/gui/kernel/qopenglcontext.cpp
+++ b/src/gui/kernel/qopenglcontext.cpp
@@ -661,8 +661,6 @@ void QOpenGLContext::destroy()
     d->externalVersionFunctions.clear();
     qDeleteAll(d->versionFunctions);
     d->versionFunctions.clear();
-    qDeleteAll(d->versionFunctionsBackend);
-    d->versionFunctionsBackend.clear();
 
     delete d->textureFunctions;
     d->textureFunctions = 0;
@@ -1035,19 +1033,19 @@ void QOpenGLContext::swapBuffers(QSurface *surface)
         return;
 
     if (!surface) {
-        qWarning() << "QOpenGLContext::swapBuffers() called with null argument";
+        qWarning("QOpenGLContext::swapBuffers() called with null argument");
         return;
     }
 
     if (!surface->supportsOpenGL()) {
-        qWarning() << "QOpenGLContext::swapBuffers() called with non-opengl surface";
+        qWarning("QOpenGLContext::swapBuffers() called with non-opengl surface");
         return;
     }
 
     if (surface->surfaceClass() == QSurface::Window
         && !qt_window_private(static_cast<QWindow *>(surface))->receivedExpose)
     {
-        qWarning() << "QOpenGLContext::swapBuffers() called with non-exposed window, behavior is undefined";
+        qWarning("QOpenGLContext::swapBuffers() called with non-exposed window, behavior is undefined");
     }
 
     QPlatformSurface *surfaceHandle = surface->surfaceHandle();
@@ -1056,7 +1054,7 @@ void QOpenGLContext::swapBuffers(QSurface *surface)
 
 #if !defined(QT_NO_DEBUG)
     if (!QOpenGLContextPrivate::toggleMakeCurrentTracker(this, false))
-        qWarning() << "QOpenGLContext::swapBuffers() called without corresponding makeCurrent()";
+        qWarning("QOpenGLContext::swapBuffers() called without corresponding makeCurrent()");
 #endif
     if (surface->format().swapBehavior() == QSurfaceFormat::SingleBuffer)
         functions()->glFlush();
@@ -1069,10 +1067,19 @@ void QOpenGLContext::swapBuffers(QSurface *surface)
     Returns 0 if no such function can be found.
 */
 QFunctionPointer QOpenGLContext::getProcAddress(const QByteArray &procName) const
+{
+    return getProcAddress(procName.constData());
+}
+
+/*!
+  \overload
+  \since 5.8
+ */
+QFunctionPointer QOpenGLContext::getProcAddress(const char *procName) const
 {
     Q_D(const QOpenGLContext);
     if (!d->platformGLContext)
-        return 0;
+        return nullptr;
     return d->platformGLContext->getProcAddress(procName);
 }
 
@@ -1293,29 +1300,10 @@ QOpenGLContext *QOpenGLContext::globalShareContext()
 /*!
     \internal
 */
-QOpenGLVersionFunctionsBackend *QOpenGLContext::functionsBackend(const QOpenGLVersionStatus &v) const
+QOpenGLVersionFunctionsStorage *QOpenGLContext::functionsBackendStorage() const
 {
     Q_D(const QOpenGLContext);
-    return d->versionFunctionsBackend.value(v, 0);
-}
-
-/*!
-    \internal
-*/
-void QOpenGLContext::insertFunctionsBackend(const QOpenGLVersionStatus &v,
-                                            QOpenGLVersionFunctionsBackend *backend)
-{
-    Q_D(QOpenGLContext);
-    d->versionFunctionsBackend.insert(v, backend);
-}
-
-/*!
-    \internal
-*/
-void QOpenGLContext::removeFunctionsBackend(const QOpenGLVersionStatus &v)
-{
-    Q_D(QOpenGLContext);
-    d->versionFunctionsBackend.remove(v);
+    return &d->versionFunctionsStorage;
 }
 
 /*!
diff --git a/src/gui/kernel/qopenglcontext.h b/src/gui/kernel/qopenglcontext.h
index 56eb6f0e122..33e3f1c3f68 100644
--- a/src/gui/kernel/qopenglcontext.h
+++ b/src/gui/kernel/qopenglcontext.h
@@ -174,6 +174,7 @@ public:
 
     void swapBuffers(QSurface *surface);
     QFunctionPointer getProcAddress(const QByteArray &procName) const;
+    QFunctionPointer getProcAddress(const char *procName) const;
 
     QSurface *surface() const;
 
@@ -236,10 +237,7 @@ private:
     void setQGLContextHandle(void *handle,void (*qGLContextDeleteFunction)(void *));
     void deleteQGLContext();
 
-    QOpenGLVersionFunctionsBackend* functionsBackend(const QOpenGLVersionStatus &v) const;
-    void insertFunctionsBackend(const QOpenGLVersionStatus &v,
-                                QOpenGLVersionFunctionsBackend *backend);
-    void removeFunctionsBackend(const QOpenGLVersionStatus &v);
+    QOpenGLVersionFunctionsStorage* functionsBackendStorage() const;
     void insertExternalFunctions(QAbstractOpenGLFunctions *f);
     void removeExternalFunctions(QAbstractOpenGLFunctions *f);
 
diff --git a/src/gui/kernel/qopenglcontext_p.h b/src/gui/kernel/qopenglcontext_p.h
index 7fc922f3881..4a5fbab364e 100644
--- a/src/gui/kernel/qopenglcontext_p.h
+++ b/src/gui/kernel/qopenglcontext_p.h
@@ -222,7 +222,7 @@ public:
     }
 
     mutable QHash<QOpenGLVersionProfile, QAbstractOpenGLFunctions *> versionFunctions;
-    mutable QHash<QOpenGLVersionStatus, QOpenGLVersionFunctionsBackend *> versionFunctionsBackend;
+    mutable QOpenGLVersionFunctionsStorage versionFunctionsStorage;
     mutable QSet<QAbstractOpenGLFunctions *> externalVersionFunctions;
 
     void *qGLContextHandle;
diff --git a/src/gui/kernel/qopenglwindow.cpp b/src/gui/kernel/qopenglwindow.cpp
index 37db6084302..8ab5c084421 100644
--- a/src/gui/kernel/qopenglwindow.cpp
+++ b/src/gui/kernel/qopenglwindow.cpp
@@ -252,9 +252,10 @@ void QOpenGLWindowPrivate::beginPaint(const QRegion &region)
         if (!fbo || fbo->size() != deviceSize) {
             QOpenGLFramebufferObjectFormat fboFormat;
             fboFormat.setAttachment(QOpenGLFramebufferObject::CombinedDepthStencil);
-            if (q->requestedFormat().samples() > 0) {
+            const int samples = q->requestedFormat().samples();
+            if (samples > 0) {
                 if (updateBehavior != QOpenGLWindow::PartialUpdateBlend)
-                    fboFormat.setSamples(q->requestedFormat().samples());
+                    fboFormat.setSamples(samples);
                 else
                     qWarning("QOpenGLWindow: PartialUpdateBlend does not support multisampling");
             }
diff --git a/src/gui/kernel/qplatformintegration.cpp b/src/gui/kernel/qplatformintegration.cpp
index 06e41f73648..a0e65654a6d 100644
--- a/src/gui/kernel/qplatformintegration.cpp
+++ b/src/gui/kernel/qplatformintegration.cpp
@@ -224,7 +224,8 @@ QPlatformServices *QPlatformIntegration::services() const
     platforms where no window management is available, meaning for example that windows
     are never repositioned by the window manager. The default implementation returns \c true.
 
-    \value AllGLFunctionsQueryable The QOpenGLContext backend provided by the platform is
+    \value AllGLFunctionsQueryable Deprecated. Used to indicate whether the QOpenGLContext
+    backend provided by the platform is
     able to return function pointers from getProcAddress() even for standard OpenGL
     functions, for example OpenGL 1 functions like glClear() or glDrawArrays(). This is
     important because the OpenGL specifications do not require this ability from the
@@ -232,7 +233,8 @@ QPlatformServices *QPlatformIntegration::services() const
     platform plugins may however choose to enhance the behavior in the backend
     implementation for QOpenGLContext::getProcAddress() and support returning a function
     pointer also for the standard, non-extension functions. This capability is a
-    prerequisite for dynamic OpenGL loading.
+    prerequisite for dynamic OpenGL loading. Starting with Qt 5.7, the platform plugin
+    is required to have this capability.
 
     \value ApplicationIcon The platform supports setting the application icon. (since 5.5)
  */
diff --git a/src/gui/kernel/qplatformmenu.h b/src/gui/kernel/qplatformmenu.h
index 22848fcff64..bd4f4d9bebd 100644
--- a/src/gui/kernel/qplatformmenu.h
+++ b/src/gui/kernel/qplatformmenu.h
@@ -148,6 +148,7 @@ public:
     virtual void handleReparent(QWindow *newParentWindow) = 0;
 
     virtual QPlatformMenu *menuForTag(quintptr tag) const = 0;
+    virtual QPlatformMenu *createMenu() const { return nullptr; }
 };
 
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qplatformopenglcontext.cpp b/src/gui/kernel/qplatformopenglcontext.cpp
index 2457a5237d6..07b5a0dda60 100644
--- a/src/gui/kernel/qplatformopenglcontext.cpp
+++ b/src/gui/kernel/qplatformopenglcontext.cpp
@@ -71,10 +71,11 @@ QT_BEGIN_NAMESPACE
     The implementation must support being called in a thread different than the gui-thread.
 */
 
-/*! \fn QFunctionPointer QPlatformOpenGLContext::getProcAddress(const QByteArray &procName)
-    Reimplement in subclass to native getProcAddr calls.
+/*! \fn QFunctionPointer QPlatformOpenGLContext::getProcAddress(const char *procName)
 
-    Note: its convenient to use qPrintable(const QString &str) to get the const char * pointer
+    Reimplement in subclass to allow dynamic querying of OpenGL symbols. As opposed to e.g. the wglGetProcAddress
+    function on Windows, Qt expects this methods to be able to return valid function pointers even for standard
+    OpenGL symbols.
 */
 
 class QPlatformOpenGLContextPrivate
diff --git a/src/gui/kernel/qplatformopenglcontext.h b/src/gui/kernel/qplatformopenglcontext.h
index f2ec1c1a7e6..1a38a5fed34 100644
--- a/src/gui/kernel/qplatformopenglcontext.h
+++ b/src/gui/kernel/qplatformopenglcontext.h
@@ -83,7 +83,7 @@ public:
     virtual bool isSharing() const { return false; }
     virtual bool isValid() const { return true; }
 
-    virtual QFunctionPointer getProcAddress(const QByteArray &procName) = 0;
+    virtual QFunctionPointer getProcAddress(const char *procName) = 0;
 
     QOpenGLContext *context() const;
 
diff --git a/src/gui/kernel/qplatformtheme.h b/src/gui/kernel/qplatformtheme.h
index 77e063f8898..c4c7482995e 100644
--- a/src/gui/kernel/qplatformtheme.h
+++ b/src/gui/kernel/qplatformtheme.h
@@ -172,6 +172,7 @@ public:
         FixedFont,
         GroupBoxTitleFont,
         TabButtonFont,
+        EditorFont,
         NFonts
     };
 
diff --git a/src/gui/kernel/qplatformwindow.cpp b/src/gui/kernel/qplatformwindow.cpp
index 347d02d6163..e45a1d61ba6 100644
--- a/src/gui/kernel/qplatformwindow.cpp
+++ b/src/gui/kernel/qplatformwindow.cpp
@@ -499,9 +499,10 @@ QPlatformScreen *QPlatformWindow::screenForGeometry(const QRect &newGeometry) co
     if (!parent() && currentScreen && !currentScreen->geometry().contains(center)) {
         const auto screens = currentScreen->virtualSiblings();
         for (QPlatformScreen *screen : screens) {
-            if (screen->geometry().contains(center))
+            const QRect screenGeometry = screen->geometry();
+            if (screenGeometry.contains(center))
                 return screen;
-            if (screen->geometry().intersects(newGeometry))
+            if (screenGeometry.intersects(newGeometry))
                 fallback = screen;
         }
     }
diff --git a/src/gui/kernel/qrasterwindow.cpp b/src/gui/kernel/qrasterwindow.cpp
index 947f2bb6a8f..d8d448249e9 100644
--- a/src/gui/kernel/qrasterwindow.cpp
+++ b/src/gui/kernel/qrasterwindow.cpp
@@ -73,8 +73,9 @@ public:
     void beginPaint(const QRegion &region) Q_DECL_OVERRIDE
     {
         Q_Q(QRasterWindow);
-        if (backingstore->size() != q->size()) {
-            backingstore->resize(q->size());
+        const QSize size = q->size();
+        if (backingstore->size() != size) {
+            backingstore->resize(size);
             markWindowAsDirty();
         }
         backingstore->beginPaint(region);
diff --git a/src/gui/kernel/qsessionmanager.cpp b/src/gui/kernel/qsessionmanager.cpp
index f7414868d98..493a321c745 100644
--- a/src/gui/kernel/qsessionmanager.cpp
+++ b/src/gui/kernel/qsessionmanager.cpp
@@ -70,22 +70,21 @@ QT_BEGIN_NAMESPACE
     settings.
 
     QSessionManager provides an interface between the application and the
-    session manager so that the program can work well with the session manager.
-    In Qt, session management requests for action are handled by the two
-    signals QGuiApplication::commitDataRequest() and
-    QGuiApplication::saveStateRequest(). Both provide a reference to a session
-    manager object as argument, to allow the application to communicate with
-    the session manager. The session manager can only be accessed through these
-    functions.
+    platform's session manager. In Qt, session management requests for action
+    are handled by the two signals QGuiApplication::commitDataRequest() and
+    QGuiApplication::saveStateRequest(). Both provide a reference to a
+    QSessionManager object as argument. The session manager can only be
+    accessed in slots invoked by these signals.
+
+    \warning If you use QSessionManager, you should disable fallback session
+    management: QGuiApplication::setFallbackSessionManagementEnabled().
 
     No user interaction is possible \e unless the application gets explicit
     permission from the session manager. You ask for permission by calling
     allowsInteraction() or, if it is really urgent, allowsErrorInteraction().
     Qt does not enforce this, but the session manager may.
 
-    You can try to abort the shutdown process by calling cancel(). The default
-    commitData() function does this if some top-level window rejected its
-    closeEvent().
+    You can try to abort the shutdown process by calling cancel().
 
     For sophisticated session managers provided on Unix/X11, QSessionManager
     offers further possibilities to fine-tune an application's session
diff --git a/src/gui/kernel/qshapedpixmapdndwindow.cpp b/src/gui/kernel/qshapedpixmapdndwindow.cpp
index 2cfbc4caa4e..40bf15b8076 100644
--- a/src/gui/kernel/qshapedpixmapdndwindow.cpp
+++ b/src/gui/kernel/qshapedpixmapdndwindow.cpp
@@ -48,52 +48,31 @@
 QT_BEGIN_NAMESPACE
 
 QShapedPixmapWindow::QShapedPixmapWindow(QScreen *screen)
-    : QWindow(screen),
-      m_backingStore(0),
-      m_useCompositing(true)
+    : m_useCompositing(true)
 {
+    setScreen(screen);
     QSurfaceFormat format;
     format.setAlphaBufferSize(8);
     setFormat(format);
-    setSurfaceType(RasterSurface);
-    setFlags(Qt::ToolTip | Qt::FramelessWindowHint |
-                   Qt::X11BypassWindowManagerHint | Qt::WindowTransparentForInput | Qt::WindowDoesNotAcceptFocus);
-    create();
-    m_backingStore = new QBackingStore(this);
+    setFlags(Qt::ToolTip | Qt::FramelessWindowHint | Qt::X11BypassWindowManagerHint
+             | Qt::WindowTransparentForInput | Qt::WindowDoesNotAcceptFocus);
 }
 
 QShapedPixmapWindow::~QShapedPixmapWindow()
 {
-    delete m_backingStore;
-    m_backingStore = 0;
-}
-
-void QShapedPixmapWindow::render()
-{
-    QRect rect(QPoint(), geometry().size());
-
-    m_backingStore->beginPaint(rect);
-
-    QPaintDevice *device = m_backingStore->paintDevice();
-
-    {
-        QPainter p(device);
-        if (m_useCompositing)
-            p.setCompositionMode(QPainter::CompositionMode_Source);
-        else
-            p.fillRect(rect, QGuiApplication::palette().base());
-        p.drawPixmap(0, 0, m_pixmap);
-    }
-
-    m_backingStore->endPaint();
-    m_backingStore->flush(rect);
 }
 
 void QShapedPixmapWindow::setPixmap(const QPixmap &pixmap)
 {
     m_pixmap = pixmap;
-    if (!m_useCompositing)
-        setMask(m_pixmap.mask());
+    if (!m_useCompositing) {
+        const QBitmap mask = m_pixmap.mask();
+        if (!mask.isNull()) {
+            if (!handle())
+                create();
+            setMask(mask);
+        }
+    }
 }
 
 void QShapedPixmapWindow::setHotspot(const QPoint &hotspot)
@@ -101,19 +80,28 @@ void QShapedPixmapWindow::setHotspot(const QPoint &hotspot)
     m_hotSpot = hotspot;
 }
 
-void QShapedPixmapWindow::updateGeometry(const QPoint &pos)
+void QShapedPixmapWindow::paintEvent(QPaintEvent *)
 {
-    if (m_pixmap.isNull())
-        m_backingStore->resize(QSize(1,1));
-    else if (m_backingStore->size() != m_pixmap.size())
-        m_backingStore->resize(m_pixmap.size());
-
-    setGeometry(QRect(pos - m_hotSpot, m_backingStore->size()));
+    if (!m_pixmap.isNull()) {
+        const QRect rect(QPoint(0, 0), size());
+        QPainter painter(this);
+        if (m_useCompositing)
+            painter.setCompositionMode(QPainter::CompositionMode_Source);
+        else
+            painter.fillRect(rect, QGuiApplication::palette().base());
+        painter.drawPixmap(rect, m_pixmap);
+    }
 }
 
-void QShapedPixmapWindow::exposeEvent(QExposeEvent *)
+void QShapedPixmapWindow::updateGeometry(const QPoint &pos)
 {
-    render();
+    QSize size(1, 1);
+    if (!m_pixmap.isNull()) {
+        size = qFuzzyCompare(m_pixmap.devicePixelRatio(), 1.0)
+            ? m_pixmap.size()
+            : (QSizeF(m_pixmap.size()) / m_pixmap.devicePixelRatio()).toSize();
+    }
+    setGeometry(QRect(pos - m_hotSpot, size));
 }
 
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qshapedpixmapdndwindow_p.h b/src/gui/kernel/qshapedpixmapdndwindow_p.h
index 65a4e3cfa71..21cecba9e8b 100644
--- a/src/gui/kernel/qshapedpixmapdndwindow_p.h
+++ b/src/gui/kernel/qshapedpixmapdndwindow_p.h
@@ -51,21 +51,18 @@
 // We mean it.
 //
 
-#include <QtGui/QWindow>
+#include <QtGui/QRasterWindow>
 #include <QtGui/QPixmap>
-#include <QtGui/QBackingStore>
 
 QT_BEGIN_NAMESPACE
 
-class QShapedPixmapWindow : public QWindow
+class QShapedPixmapWindow : public QRasterWindow
 {
     Q_OBJECT
 public:
     explicit QShapedPixmapWindow(QScreen *screen = 0);
     ~QShapedPixmapWindow();
 
-    void render();
-
     void setUseCompositing(bool on) { m_useCompositing = on; }
     void setPixmap(const QPixmap &pixmap);
     void setHotspot(const QPoint &hotspot);
@@ -73,10 +70,9 @@ public:
     void updateGeometry(const QPoint &pos);
 
 protected:
-    void exposeEvent(QExposeEvent *) Q_DECL_OVERRIDE;
+    void paintEvent(QPaintEvent *) Q_DECL_OVERRIDE;
 
 private:
-    QBackingStore *m_backingStore;
     QPixmap m_pixmap;
     QPoint m_hotSpot;
     bool m_useCompositing;
diff --git a/src/gui/kernel/qstylehints.cpp b/src/gui/kernel/qstylehints.cpp
index e184fed2750..ecc2886a044 100644
--- a/src/gui/kernel/qstylehints.cpp
+++ b/src/gui/kernel/qstylehints.cpp
@@ -54,7 +54,7 @@ static inline QVariant themeableHint(QPlatformTheme::ThemeHint th,
                                      QPlatformIntegration::StyleHint ih)
 {
     if (!QCoreApplication::instance()) {
-        qWarning() << "Must construct a QGuiApplication before accessing a platform theme hint.";
+        qWarning("Must construct a QGuiApplication before accessing a platform theme hint.");
         return QVariant();
     }
     if (const QPlatformTheme *theme = QGuiApplicationPrivate::platformTheme()) {
diff --git a/src/gui/kernel/qwindow.cpp b/src/gui/kernel/qwindow.cpp
index f43ef43c6cc..107ea73a565 100644
--- a/src/gui/kernel/qwindow.cpp
+++ b/src/gui/kernel/qwindow.cpp
@@ -1145,7 +1145,7 @@ qreal QWindow::devicePixelRatio() const
 void QWindow::setWindowState(Qt::WindowState state)
 {
     if (state == Qt::WindowActive) {
-        qWarning() << "QWindow::setWindowState does not accept Qt::WindowActive";
+        qWarning("QWindow::setWindowState does not accept Qt::WindowActive");
         return;
     }
 
@@ -1469,9 +1469,9 @@ void QWindow::setGeometry(const QRect &rect)
 {
     Q_D(QWindow);
     d->positionAutomatic = false;
-    if (rect == geometry())
+    const QRect oldRect = geometry();
+    if (rect == oldRect)
         return;
-    QRect oldRect = geometry();
 
     d->positionPolicy = QWindowPrivate::WindowFrameExclusive;
     if (d->platformWindow) {
@@ -2436,7 +2436,7 @@ QWindow *QWindowPrivate::topLevelWindow() const
 QWindow *QWindow::fromWinId(WId id)
 {
     if (!QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::ForeignWindows)) {
-        qWarning() << "QWindow::fromWinId(): platform plugin does not support foreign windows.";
+        qWarning("QWindow::fromWinId(): platform plugin does not support foreign windows.");
         return 0;
     }
 
diff --git a/src/gui/kernel/qwindowsysteminterface.cpp b/src/gui/kernel/qwindowsysteminterface.cpp
index 39bc161a7c1..5b91f1bc7e3 100644
--- a/src/gui/kernel/qwindowsysteminterface.cpp
+++ b/src/gui/kernel/qwindowsysteminterface.cpp
@@ -315,7 +315,8 @@ void QWindowSystemInterface::handleWheelEvent(QWindow *w, const QPointF & local,
     handleWheelEvent(w, time, local, global, pixelDelta, angleDelta, mods, phase, source);
 }
 
-void QWindowSystemInterface::handleWheelEvent(QWindow *tlw, ulong timestamp, const QPointF & local, const QPointF & global, QPoint pixelDelta, QPoint angleDelta, Qt::KeyboardModifiers mods, Qt::ScrollPhase phase, Qt::MouseEventSource source)
+void QWindowSystemInterface::handleWheelEvent(QWindow *tlw, ulong timestamp, const QPointF & local, const QPointF & global, QPoint pixelDelta, QPoint angleDelta, Qt::KeyboardModifiers mods, Qt::ScrollPhase phase,
+                                              Qt::MouseEventSource source, bool invertedScrolling)
 {
     // Qt 4 sends two separate wheel events for horizontal and vertical
     // deltas. For Qt 5 we want to send the deltas in one event, but at the
@@ -333,14 +334,15 @@ void QWindowSystemInterface::handleWheelEvent(QWindow *tlw, ulong timestamp, con
 
     // Simple case: vertical deltas only:
     if (angleDelta.y() != 0 && angleDelta.x() == 0) {
-        e = new QWindowSystemInterfacePrivate::WheelEvent(tlw, timestamp, QHighDpi::fromNativeLocalPosition(local, tlw), QHighDpi::fromNativePixels(global, tlw), pixelDelta, angleDelta, angleDelta.y(), Qt::Vertical, mods, phase, source);
+        e = new QWindowSystemInterfacePrivate::WheelEvent(tlw, timestamp, QHighDpi::fromNativeLocalPosition(local, tlw), QHighDpi::fromNativePixels(global, tlw), pixelDelta, angleDelta, angleDelta.y(), Qt::Vertical,
+                                                          mods, phase, source, invertedScrolling);
         QWindowSystemInterfacePrivate::handleWindowSystemEvent(e);
         return;
     }
 
     // Simple case: horizontal deltas only:
     if (angleDelta.y() == 0 && angleDelta.x() != 0) {
-        e = new QWindowSystemInterfacePrivate::WheelEvent(tlw, timestamp, QHighDpi::fromNativeLocalPosition(local, tlw), QHighDpi::fromNativePixels(global, tlw), pixelDelta, angleDelta, angleDelta.x(), Qt::Horizontal, mods, phase, source);
+        e = new QWindowSystemInterfacePrivate::WheelEvent(tlw, timestamp, QHighDpi::fromNativeLocalPosition(local, tlw), QHighDpi::fromNativePixels(global, tlw), pixelDelta, angleDelta, angleDelta.x(), Qt::Horizontal, mods, phase, source, invertedScrolling);
         QWindowSystemInterfacePrivate::handleWindowSystemEvent(e);
         return;
     }
@@ -348,12 +350,12 @@ void QWindowSystemInterface::handleWheelEvent(QWindow *tlw, ulong timestamp, con
     // Both horizontal and vertical deltas: Send two wheel events.
     // The first event contains the Qt 5 pixel and angle delta as points,
     // and in addition the Qt 4 compatibility vertical angle delta.
-    e = new QWindowSystemInterfacePrivate::WheelEvent(tlw, timestamp, QHighDpi::fromNativeLocalPosition(local, tlw), QHighDpi::fromNativePixels(global, tlw), pixelDelta, angleDelta, angleDelta.y(), Qt::Vertical, mods, phase, source);
+    e = new QWindowSystemInterfacePrivate::WheelEvent(tlw, timestamp, QHighDpi::fromNativeLocalPosition(local, tlw), QHighDpi::fromNativePixels(global, tlw), pixelDelta, angleDelta, angleDelta.y(), Qt::Vertical, mods, phase, source, invertedScrolling);
     QWindowSystemInterfacePrivate::handleWindowSystemEvent(e);
 
     // The second event contains null pixel and angle points and the
     // Qt 4 compatibility horizontal angle delta.
-    e = new QWindowSystemInterfacePrivate::WheelEvent(tlw, timestamp, QHighDpi::fromNativeLocalPosition(local, tlw), QHighDpi::fromNativePixels(global, tlw), QPoint(), QPoint(), angleDelta.x(), Qt::Horizontal, mods, phase, source);
+    e = new QWindowSystemInterfacePrivate::WheelEvent(tlw, timestamp, QHighDpi::fromNativeLocalPosition(local, tlw), QHighDpi::fromNativePixels(global, tlw), QPoint(), QPoint(), angleDelta.x(), Qt::Horizontal, mods, phase, source, invertedScrolling);
     QWindowSystemInterfacePrivate::handleWindowSystemEvent(e);
 }
 
@@ -863,7 +865,9 @@ Q_GUI_EXPORT void qt_handleMouseEvent(QWindow *w, const QPointF &local, const QP
 {
     bool wasSynchronous = QWindowSystemInterfacePrivate::synchronousWindowSystemEvents;
     QWindowSystemInterface::setSynchronousWindowSystemEvents(true);
-    QWindowSystemInterface::handleMouseEvent(w, timestamp, local, global, b, mods);
+    const qreal factor = QHighDpiScaling::factor(w);
+    QWindowSystemInterface::handleMouseEvent(w, timestamp, local * factor,
+                                             global * factor, b, mods);
     QWindowSystemInterface::setSynchronousWindowSystemEvents(wasSynchronous);
 }
 
@@ -912,36 +916,14 @@ Q_GUI_EXPORT bool qt_sendShortcutOverrideEvent(QObject *o, ulong timestamp, int
 #endif
 }
 
-static QWindowSystemInterface::TouchPoint touchPoint(const QTouchEvent::TouchPoint& pt)
-{
-    QWindowSystemInterface::TouchPoint p;
-    p.id = pt.id();
-    p.flags = pt.flags();
-    p.normalPosition = pt.normalizedPos();
-    p.area = pt.screenRect();
-    p.pressure = pt.pressure();
-    p.state = pt.state();
-    p.velocity = pt.velocity();
-    p.rawPositions = pt.rawScreenPositions();
-    return p;
-}
-static QList<struct QWindowSystemInterface::TouchPoint> touchPointList(const QList<QTouchEvent::TouchPoint>& pointList)
-{
-    QList<struct QWindowSystemInterface::TouchPoint> newList;
-    newList.reserve(pointList.size());
-    for (const QTouchEvent::TouchPoint &p : pointList)
-        newList.append(touchPoint(p));
-
-    return newList;
-}
-
 Q_GUI_EXPORT void qt_handleTouchEvent(QWindow *w, QTouchDevice *device,
                                 const QList<QTouchEvent::TouchPoint> &points,
                                 Qt::KeyboardModifiers mods = Qt::NoModifier)
 {
     bool wasSynchronous = QWindowSystemInterfacePrivate::synchronousWindowSystemEvents;
     QWindowSystemInterface::setSynchronousWindowSystemEvents(true);
-    QWindowSystemInterface::handleTouchEvent(w, device, touchPointList(points), mods);
+    QWindowSystemInterface::handleTouchEvent(w, device,
+                                             QWindowSystemInterfacePrivate::toNativeTouchPoints(points, w), mods);
     QWindowSystemInterface::setSynchronousWindowSystemEvents(wasSynchronous);
 }
 
@@ -956,5 +938,11 @@ bool QWindowSystemEventHandler::sendEvent(QWindowSystemInterfacePrivate::WindowS
     return true;
 }
 
+QWindowSystemInterfacePrivate::WheelEvent::WheelEvent(QWindow *w, ulong time, const QPointF &local, const QPointF &global, QPoint pixelD,
+        QPoint angleD, int qt4D, Qt::Orientation qt4O, Qt::KeyboardModifiers mods, Qt::ScrollPhase phase, Qt::MouseEventSource src, bool inverted)
+    : InputEvent(w, time, Wheel, mods), pixelDelta(pixelD), angleDelta(angleD), qt4Delta(qt4D),
+      qt4Orientation(qt4O), localPos(local), globalPos(global), phase(phase), source(src), inverted(inverted)
+{
+}
 
 QT_END_NAMESPACE
diff --git a/src/gui/kernel/qwindowsysteminterface.h b/src/gui/kernel/qwindowsysteminterface.h
index 66a4afb0850..eff39867886 100644
--- a/src/gui/kernel/qwindowsysteminterface.h
+++ b/src/gui/kernel/qwindowsysteminterface.h
@@ -109,7 +109,8 @@ public:
                                  QPoint pixelDelta, QPoint angleDelta,
                                  Qt::KeyboardModifiers mods = Qt::NoModifier,
                                  Qt::ScrollPhase phase = Qt::NoScrollPhase,
-                                 Qt::MouseEventSource source = Qt::MouseEventNotSynthesized);
+                                 Qt::MouseEventSource source = Qt::MouseEventNotSynthesized,
+                                 bool inverted = false);
 
     // Wheel event compatibility functions. Will be removed: do not use.
     static void handleWheelEvent(QWindow *w, const QPointF & local, const QPointF & global, int d, Qt::Orientation o, Qt::KeyboardModifiers mods = Qt::NoModifier);
diff --git a/src/gui/kernel/qwindowsysteminterface_p.h b/src/gui/kernel/qwindowsysteminterface_p.h
index 523aa984a9c..3ccf815c542 100644
--- a/src/gui/kernel/qwindowsysteminterface_p.h
+++ b/src/gui/kernel/qwindowsysteminterface_p.h
@@ -242,8 +242,7 @@ public:
     class WheelEvent : public InputEvent {
     public:
         WheelEvent(QWindow *w, ulong time, const QPointF & local, const QPointF & global, QPoint pixelD, QPoint angleD, int qt4D, Qt::Orientation qt4O,
-                   Qt::KeyboardModifiers mods, Qt::ScrollPhase phase = Qt::NoScrollPhase, Qt::MouseEventSource src = Qt::MouseEventNotSynthesized)
-            : InputEvent(w, time, Wheel, mods), pixelDelta(pixelD), angleDelta(angleD), qt4Delta(qt4D), qt4Orientation(qt4O), localPos(local), globalPos(global), phase(phase), source(src) { }
+                   Qt::KeyboardModifiers mods, Qt::ScrollPhase phase = Qt::NoScrollPhase, Qt::MouseEventSource src = Qt::MouseEventNotSynthesized, bool inverted = false);
         QPoint pixelDelta;
         QPoint angleDelta;
         int qt4Delta;
@@ -252,6 +251,7 @@ public:
         QPointF globalPos;
         Qt::ScrollPhase phase;
         Qt::MouseEventSource source;
+        bool inverted;
     };
 
     class KeyEvent : public InputEvent {
diff --git a/src/gui/math3d/qgenericmatrix.h b/src/gui/math3d/qgenericmatrix.h
index b7a61965154..5e22fa67304 100644
--- a/src/gui/math3d/qgenericmatrix.h
+++ b/src/gui/math3d/qgenericmatrix.h
@@ -103,6 +103,17 @@ private:
     friend class QGenericMatrix;
 #endif
 };
+template <int N, int M, typename T>
+class QTypeInfo<QGenericMatrix<N, M, T> >
+    : public QTypeInfoMerger<QGenericMatrix<N, M, T>, T>
+{
+#if QT_VERSION < QT_VERSION_CHECK(6,0,0)
+public:
+    enum {
+        isStatic = true,
+    }; // at least Q_RELOCATABLE_TYPE, for BC during Qt 5
+#endif
+};
 
 template <int N, int M, typename T>
 Q_INLINE_TEMPLATE QGenericMatrix<N, M, T>::QGenericMatrix()
diff --git a/src/gui/opengl/qopengldebug.cpp b/src/gui/opengl/qopengldebug.cpp
index 5f0164c3e12..24aa6094dde 100644
--- a/src/gui/opengl/qopengldebug.cpp
+++ b/src/gui/opengl/qopengldebug.cpp
@@ -1379,7 +1379,7 @@ bool QOpenGLDebugLogger::initialize()
 
 #define GET_DEBUG_PROC_ADDRESS(procName) \
     d->procName = reinterpret_cast< qt_ ## procName ## _t >( \
-        d->context->getProcAddress(QByteArrayLiteral( #procName )) \
+        d->context->getProcAddress(#procName) \
     );
 
     GET_DEBUG_PROC_ADDRESS(glDebugMessageControl);
@@ -1388,19 +1388,7 @@ bool QOpenGLDebugLogger::initialize()
     GET_DEBUG_PROC_ADDRESS(glGetDebugMessageLog);
     GET_DEBUG_PROC_ADDRESS(glPushDebugGroup);
     GET_DEBUG_PROC_ADDRESS(glPopDebugGroup);
-
-    // Windows' Desktop GL doesn't allow resolution of "basic GL entry points"
-    // through wglGetProcAddress
-#if defined(Q_OS_WIN) && !defined(QT_OPENGL_ES_2)
-    {
-        HMODULE handle = static_cast<HMODULE>(QOpenGLContext::openGLModuleHandle());
-        if (!handle)
-            handle = GetModuleHandleA("opengl32.dll");
-        d->glGetPointerv = reinterpret_cast<qt_glGetPointerv_t>(GetProcAddress(handle, QByteArrayLiteral("glGetPointerv")));
-    }
-#else
     GET_DEBUG_PROC_ADDRESS(glGetPointerv)
-#endif
 
 #undef GET_DEBUG_PROC_ADDRESS
 
diff --git a/src/gui/opengl/qopenglextensions_p.h b/src/gui/opengl/qopenglextensions_p.h
index 63e684438bd..894b6f2dc62 100644
--- a/src/gui/opengl/qopenglextensions_p.h
+++ b/src/gui/opengl/qopenglextensions_p.h
@@ -52,204 +52,11 @@
 //
 
 #include "qopenglextrafunctions.h"
-#include <QtCore/qlibrary.h>
 
 QT_BEGIN_NAMESPACE
 
 class QOpenGLExtensionsPrivate;
 
-class QOpenGLES3Helper
-{
-public:
-    QOpenGLES3Helper();
-
-    // GLES3
-    void (QOPENGLF_APIENTRYP ReadBuffer)(GLenum mode);
-    void (QOPENGLF_APIENTRYP DrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices);
-    void (QOPENGLF_APIENTRYP TexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);
-    void (QOPENGLF_APIENTRYP TexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
-    void (QOPENGLF_APIENTRYP CopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP CompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data);
-    void (QOPENGLF_APIENTRYP CompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
-    void (QOPENGLF_APIENTRYP GenQueries)(GLsizei n, GLuint *ids);
-    void (QOPENGLF_APIENTRYP DeleteQueries)(GLsizei n, const GLuint *ids);
-    GLboolean (QOPENGLF_APIENTRYP IsQuery)(GLuint id);
-    void (QOPENGLF_APIENTRYP BeginQuery)(GLenum target, GLuint id);
-    void (QOPENGLF_APIENTRYP EndQuery)(GLenum target);
-    void (QOPENGLF_APIENTRYP GetQueryiv)(GLenum target, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetQueryObjectuiv)(GLuint id, GLenum pname, GLuint *params);
-    GLboolean (QOPENGLF_APIENTRYP UnmapBuffer)(GLenum target);
-    void (QOPENGLF_APIENTRYP GetBufferPointerv)(GLenum target, GLenum pname, void **params);
-    void (QOPENGLF_APIENTRYP DrawBuffers)(GLsizei n, const GLenum *bufs);
-    void (QOPENGLF_APIENTRYP UniformMatrix2x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix3x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix2x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP BlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void (QOPENGLF_APIENTRYP RenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP FramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void *(QOPENGLF_APIENTRYP MapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void (QOPENGLF_APIENTRYP FlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length);
-    void (QOPENGLF_APIENTRYP BindVertexArray)(GLuint array);
-    void (QOPENGLF_APIENTRYP DeleteVertexArrays)(GLsizei n, const GLuint *arrays);
-    void (QOPENGLF_APIENTRYP GenVertexArrays)(GLsizei n, GLuint *arrays);
-    GLboolean (QOPENGLF_APIENTRYP IsVertexArray)(GLuint array);
-    void (QOPENGLF_APIENTRYP GetIntegeri_v)(GLenum target, GLuint index, GLint *data);
-    void (QOPENGLF_APIENTRYP BeginTransformFeedback)(GLenum primitiveMode);
-    void (QOPENGLF_APIENTRYP EndTransformFeedback)(void);
-    void (QOPENGLF_APIENTRYP BindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void (QOPENGLF_APIENTRYP BindBufferBase)(GLenum target, GLuint index, GLuint buffer);
-    void (QOPENGLF_APIENTRYP TransformFeedbackVaryings)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode);
-    void (QOPENGLF_APIENTRYP GetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void (QOPENGLF_APIENTRYP VertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void (QOPENGLF_APIENTRYP GetVertexAttribIiv)(GLuint index, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint *params);
-    void (QOPENGLF_APIENTRYP VertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w);
-    void (QOPENGLF_APIENTRYP VertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-    void (QOPENGLF_APIENTRYP VertexAttribI4iv)(GLuint index, const GLint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI4uiv)(GLuint index, const GLuint *v);
-    void (QOPENGLF_APIENTRYP GetUniformuiv)(GLuint program, GLint location, GLuint *params);
-    GLint (QOPENGLF_APIENTRYP GetFragDataLocation)(GLuint program, const GLchar *name);
-    void (QOPENGLF_APIENTRYP Uniform1ui)(GLint location, GLuint v0);
-    void (QOPENGLF_APIENTRYP Uniform2ui)(GLint location, GLuint v0, GLuint v1);
-    void (QOPENGLF_APIENTRYP Uniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void (QOPENGLF_APIENTRYP Uniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void (QOPENGLF_APIENTRYP Uniform1uiv)(GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP Uniform2uiv)(GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP Uniform3uiv)(GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP Uniform4uiv)(GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ClearBufferiv)(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void (QOPENGLF_APIENTRYP ClearBufferuiv)(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ClearBufferfv)(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    const GLubyte *(QOPENGLF_APIENTRYP GetStringi)(GLenum name, GLuint index);
-    void (QOPENGLF_APIENTRYP CopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void (QOPENGLF_APIENTRYP GetUniformIndices)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices);
-    void (QOPENGLF_APIENTRYP GetActiveUniformsiv)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    GLuint (QOPENGLF_APIENTRYP GetUniformBlockIndex)(GLuint program, const GLchar *uniformBlockName);
-    void (QOPENGLF_APIENTRYP GetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void (QOPENGLF_APIENTRYP UniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void (QOPENGLF_APIENTRYP DrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-    void (QOPENGLF_APIENTRYP DrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount);
-    GLsync (QOPENGLF_APIENTRYP FenceSync)(GLenum condition, GLbitfield flags);
-    GLboolean (QOPENGLF_APIENTRYP IsSync)(GLsync sync);
-    void (QOPENGLF_APIENTRYP DeleteSync)(GLsync sync);
-    GLenum (QOPENGLF_APIENTRYP ClientWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void (QOPENGLF_APIENTRYP WaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void (QOPENGLF_APIENTRYP GetInteger64v)(GLenum pname, GLint64 *data);
-    void (QOPENGLF_APIENTRYP GetSynciv)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void (QOPENGLF_APIENTRYP GetInteger64i_v)(GLenum target, GLuint index, GLint64 *data);
-    void (QOPENGLF_APIENTRYP GetBufferParameteri64v)(GLenum target, GLenum pname, GLint64 *params);
-    void (QOPENGLF_APIENTRYP GenSamplers)(GLsizei count, GLuint *samplers);
-    void (QOPENGLF_APIENTRYP DeleteSamplers)(GLsizei count, const GLuint *samplers);
-    GLboolean (QOPENGLF_APIENTRYP IsSampler)(GLuint sampler);
-    void (QOPENGLF_APIENTRYP BindSampler)(GLuint unit, GLuint sampler);
-    void (QOPENGLF_APIENTRYP SamplerParameteri)(GLuint sampler, GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP SamplerParameteriv)(GLuint sampler, GLenum pname, const GLint *param);
-    void (QOPENGLF_APIENTRYP SamplerParameterf)(GLuint sampler, GLenum pname, GLfloat param);
-    void (QOPENGLF_APIENTRYP SamplerParameterfv)(GLuint sampler, GLenum pname, const GLfloat *param);
-    void (QOPENGLF_APIENTRYP GetSamplerParameteriv)(GLuint sampler, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetSamplerParameterfv)(GLuint sampler, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP VertexAttribDivisor)(GLuint index, GLuint divisor);
-    void (QOPENGLF_APIENTRYP BindTransformFeedback)(GLenum target, GLuint id);
-    void (QOPENGLF_APIENTRYP DeleteTransformFeedbacks)(GLsizei n, const GLuint *ids);
-    void (QOPENGLF_APIENTRYP GenTransformFeedbacks)(GLsizei n, GLuint *ids);
-    GLboolean (QOPENGLF_APIENTRYP IsTransformFeedback)(GLuint id);
-    void (QOPENGLF_APIENTRYP PauseTransformFeedback)(void);
-    void (QOPENGLF_APIENTRYP ResumeTransformFeedback)(void);
-    void (QOPENGLF_APIENTRYP GetProgramBinary)(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
-    void (QOPENGLF_APIENTRYP ProgramBinary)(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length);
-    void (QOPENGLF_APIENTRYP ProgramParameteri)(GLuint program, GLenum pname, GLint value);
-    void (QOPENGLF_APIENTRYP InvalidateFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum *attachments);
-    void (QOPENGLF_APIENTRYP InvalidateSubFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP TexStorage2D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP TexStorage3D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-    void (QOPENGLF_APIENTRYP GetInternalformativ)(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
-
-    // GLES 3.1
-    void (QOPENGLF_APIENTRYP DispatchCompute)(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
-    void (QOPENGLF_APIENTRYP DispatchComputeIndirect)(GLintptr indirect);
-    void (QOPENGLF_APIENTRYP DrawArraysIndirect)(GLenum mode, const void *indirect);
-    void (QOPENGLF_APIENTRYP DrawElementsIndirect)(GLenum mode, GLenum type, const void *indirect);
-    void (QOPENGLF_APIENTRYP FramebufferParameteri)(GLenum target, GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP GetFramebufferParameteriv)(GLenum target, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetProgramInterfaceiv)(GLuint program, GLenum programInterface, GLenum pname, GLint *params);
-    GLuint (QOPENGLF_APIENTRYP GetProgramResourceIndex)(GLuint program, GLenum programInterface, const GLchar *name);
-    void (QOPENGLF_APIENTRYP GetProgramResourceName)(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name);
-    void (QOPENGLF_APIENTRYP GetProgramResourceiv)(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params);
-    GLint (QOPENGLF_APIENTRYP GetProgramResourceLocation)(GLuint program, GLenum programInterface, const GLchar *name);
-    void (QOPENGLF_APIENTRYP UseProgramStages)(GLuint pipeline, GLbitfield stages, GLuint program);
-    void (QOPENGLF_APIENTRYP ActiveShaderProgram)(GLuint pipeline, GLuint program);
-    GLuint (QOPENGLF_APIENTRYP CreateShaderProgramv)(GLenum type, GLsizei count, const GLchar *const*strings);
-    void (QOPENGLF_APIENTRYP BindProgramPipeline)(GLuint pipeline);
-    void (QOPENGLF_APIENTRYP DeleteProgramPipelines)(GLsizei n, const GLuint *pipelines);
-    void (QOPENGLF_APIENTRYP GenProgramPipelines)(GLsizei n, GLuint *pipelines);
-    GLboolean (QOPENGLF_APIENTRYP IsProgramPipeline)(GLuint pipeline);
-    void (QOPENGLF_APIENTRYP GetProgramPipelineiv)(GLuint pipeline, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP ProgramUniform1i)(GLuint program, GLint location, GLint v0);
-    void (QOPENGLF_APIENTRYP ProgramUniform2i)(GLuint program, GLint location, GLint v0, GLint v1);
-    void (QOPENGLF_APIENTRYP ProgramUniform3i)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
-    void (QOPENGLF_APIENTRYP ProgramUniform4i)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void (QOPENGLF_APIENTRYP ProgramUniform1ui)(GLuint program, GLint location, GLuint v0);
-    void (QOPENGLF_APIENTRYP ProgramUniform2ui)(GLuint program, GLint location, GLuint v0, GLuint v1);
-    void (QOPENGLF_APIENTRYP ProgramUniform3ui)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void (QOPENGLF_APIENTRYP ProgramUniform4ui)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void (QOPENGLF_APIENTRYP ProgramUniform1f)(GLuint program, GLint location, GLfloat v0);
-    void (QOPENGLF_APIENTRYP ProgramUniform2f)(GLuint program, GLint location, GLfloat v0, GLfloat v1);
-    void (QOPENGLF_APIENTRYP ProgramUniform3f)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void (QOPENGLF_APIENTRYP ProgramUniform4f)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void (QOPENGLF_APIENTRYP ProgramUniform1iv)(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform2iv)(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform3iv)(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform4iv)(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform1uiv)(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform2uiv)(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform3uiv)(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform4uiv)(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform1fv)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform2fv)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform3fv)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform4fv)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix2x3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix3x2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix2x4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix4x2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix3x4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix4x3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ValidateProgramPipeline)(GLuint pipeline);
-    void (QOPENGLF_APIENTRYP GetProgramPipelineInfoLog)(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void (QOPENGLF_APIENTRYP BindImageTexture)(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
-    void (QOPENGLF_APIENTRYP GetBooleani_v)(GLenum target, GLuint index, GLboolean *data);
-    void (QOPENGLF_APIENTRYP MemoryBarrierFunc)(GLbitfield barriers);
-    void (QOPENGLF_APIENTRYP MemoryBarrierByRegion)(GLbitfield barriers);
-    void (QOPENGLF_APIENTRYP TexStorage2DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void (QOPENGLF_APIENTRYP GetMultisamplefv)(GLenum pname, GLuint index, GLfloat *val);
-    void (QOPENGLF_APIENTRYP SampleMaski)(GLuint maskNumber, GLbitfield mask);
-    void (QOPENGLF_APIENTRYP GetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP BindVertexBuffer)(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
-    void (QOPENGLF_APIENTRYP VertexAttribFormat)(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
-    void (QOPENGLF_APIENTRYP VertexAttribIFormat)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void (QOPENGLF_APIENTRYP VertexAttribBinding)(GLuint attribindex, GLuint bindingindex);
-    void (QOPENGLF_APIENTRYP VertexBindingDivisor)(GLuint bindingindex, GLuint divisor);
-
-    QPair<int, int> supportedVersion() const { return m_supportedVersion; }
-
-private:
-    bool init();
-    QFunctionPointer resolve(const char *name);
-#ifndef QT_NO_LIBRARY
-    QLibrary m_gl;
-#endif
-    QPair<int, int> m_supportedVersion;
-};
-
 class Q_GUI_EXPORT QOpenGLExtensions : public QOpenGLExtraFunctions
 {
     Q_DECLARE_PRIVATE(QOpenGLExtensions)
@@ -293,10 +100,10 @@ public:
     void glGetBufferSubData(GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, GLvoid *data);
     void glDiscardFramebufferEXT (GLenum target, GLsizei numAttachments, const GLenum *attachments);
 
-    QOpenGLES3Helper *gles3Helper();
-
     void flushShared();
 
+    QOpenGLExtensionsPrivate *d() const;
+
 private:
     static bool isInitialized(const QOpenGLFunctionsPrivate *d) { return d != 0; }
 };
@@ -316,6 +123,11 @@ public:
     bool flushIsSufficientToSyncContexts;
 };
 
+inline QOpenGLExtensionsPrivate *QOpenGLExtensions::d() const
+{
+    return static_cast<QOpenGLExtensionsPrivate *>(d_ptr);
+}
+
 inline GLvoid *QOpenGLExtensions::glMapBuffer(GLenum target, GLenum access)
 {
     Q_D(QOpenGLExtensions);
diff --git a/src/gui/opengl/qopenglextrafunctions.h b/src/gui/opengl/qopenglextrafunctions.h
index d3b25fa3486..aa29d685bc4 100644
--- a/src/gui/opengl/qopenglextrafunctions.h
+++ b/src/gui/opengl/qopenglextrafunctions.h
@@ -46,6 +46,12 @@
 
 #include <QtGui/qopenglfunctions.h>
 
+// MemoryBarrier is a macro on some architectures on Windows
+#ifdef Q_OS_WIN
+#pragma push_macro("MemoryBarrier")
+#undef MemoryBarrier
+#endif
+
 QT_BEGIN_NAMESPACE
 
 class QOpenGLExtraFunctionsPrivate;
@@ -413,186 +419,204 @@ private:
     static bool isInitialized(const QOpenGLExtraFunctionsPrivate *d) { return d != Q_NULLPTR; }
 };
 
+
+#define QT_OPENGL_DECLARE_FUNCTIONS(ret, name, args) \
+    ret (QOPENGLF_APIENTRYP name)args;
+#define QT_OPENGL_COUNT_FUNCTIONS(ret, name, args) +1
+
+#define QT_OPENGL_DECLARE(FUNCTIONS) \
+public: \
+    struct Functions { \
+        FUNCTIONS(QT_OPENGL_DECLARE_FUNCTIONS) \
+    }; \
+    union { \
+        QFunctionPointer functions[FUNCTIONS(QT_OPENGL_COUNT_FUNCTIONS)]; \
+        Functions f; \
+    }; \
+private: \
+    void init(QOpenGLContext *context);
+
 class QOpenGLExtraFunctionsPrivate : public QOpenGLFunctionsPrivate
 {
 public:
     QOpenGLExtraFunctionsPrivate(QOpenGLContext *ctx);
 
     // GLES3
-    void (QOPENGLF_APIENTRYP ReadBuffer)(GLenum mode);
-    void (QOPENGLF_APIENTRYP DrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices);
-    void (QOPENGLF_APIENTRYP TexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels);
-    void (QOPENGLF_APIENTRYP TexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
-    void (QOPENGLF_APIENTRYP CopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP CompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data);
-    void (QOPENGLF_APIENTRYP CompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
-    void (QOPENGLF_APIENTRYP GenQueries)(GLsizei n, GLuint *ids);
-    void (QOPENGLF_APIENTRYP DeleteQueries)(GLsizei n, const GLuint *ids);
-    GLboolean (QOPENGLF_APIENTRYP IsQuery)(GLuint id);
-    void (QOPENGLF_APIENTRYP BeginQuery)(GLenum target, GLuint id);
-    void (QOPENGLF_APIENTRYP EndQuery)(GLenum target);
-    void (QOPENGLF_APIENTRYP GetQueryiv)(GLenum target, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetQueryObjectuiv)(GLuint id, GLenum pname, GLuint *params);
-    GLboolean (QOPENGLF_APIENTRYP UnmapBuffer)(GLenum target);
-    void (QOPENGLF_APIENTRYP GetBufferPointerv)(GLenum target, GLenum pname, void **params);
-    void (QOPENGLF_APIENTRYP DrawBuffers)(GLsizei n, const GLenum *bufs);
-    void (QOPENGLF_APIENTRYP UniformMatrix2x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix3x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix2x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP BlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void (QOPENGLF_APIENTRYP RenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP FramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void *(QOPENGLF_APIENTRYP MapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void (QOPENGLF_APIENTRYP FlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length);
-    void (QOPENGLF_APIENTRYP BindVertexArray)(GLuint array);
-    void (QOPENGLF_APIENTRYP DeleteVertexArrays)(GLsizei n, const GLuint *arrays);
-    void (QOPENGLF_APIENTRYP GenVertexArrays)(GLsizei n, GLuint *arrays);
-    GLboolean (QOPENGLF_APIENTRYP IsVertexArray)(GLuint array);
-    void (QOPENGLF_APIENTRYP GetIntegeri_v)(GLenum target, GLuint index, GLint *data);
-    void (QOPENGLF_APIENTRYP BeginTransformFeedback)(GLenum primitiveMode);
-    void (QOPENGLF_APIENTRYP EndTransformFeedback)(void);
-    void (QOPENGLF_APIENTRYP BindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void (QOPENGLF_APIENTRYP BindBufferBase)(GLenum target, GLuint index, GLuint buffer);
-    void (QOPENGLF_APIENTRYP TransformFeedbackVaryings)(GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode);
-    void (QOPENGLF_APIENTRYP GetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void (QOPENGLF_APIENTRYP VertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer);
-    void (QOPENGLF_APIENTRYP GetVertexAttribIiv)(GLuint index, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint *params);
-    void (QOPENGLF_APIENTRYP VertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w);
-    void (QOPENGLF_APIENTRYP VertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-    void (QOPENGLF_APIENTRYP VertexAttribI4iv)(GLuint index, const GLint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI4uiv)(GLuint index, const GLuint *v);
-    void (QOPENGLF_APIENTRYP GetUniformuiv)(GLuint program, GLint location, GLuint *params);
-    GLint (QOPENGLF_APIENTRYP GetFragDataLocation)(GLuint program, const GLchar *name);
-    void (QOPENGLF_APIENTRYP Uniform1ui)(GLint location, GLuint v0);
-    void (QOPENGLF_APIENTRYP Uniform2ui)(GLint location, GLuint v0, GLuint v1);
-    void (QOPENGLF_APIENTRYP Uniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void (QOPENGLF_APIENTRYP Uniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void (QOPENGLF_APIENTRYP Uniform1uiv)(GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP Uniform2uiv)(GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP Uniform3uiv)(GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP Uniform4uiv)(GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ClearBufferiv)(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void (QOPENGLF_APIENTRYP ClearBufferuiv)(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ClearBufferfv)(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    const GLubyte *(QOPENGLF_APIENTRYP GetStringi)(GLenum name, GLuint index);
-    void (QOPENGLF_APIENTRYP CopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void (QOPENGLF_APIENTRYP GetUniformIndices)(GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices);
-    void (QOPENGLF_APIENTRYP GetActiveUniformsiv)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    GLuint (QOPENGLF_APIENTRYP GetUniformBlockIndex)(GLuint program, const GLchar *uniformBlockName);
-    void (QOPENGLF_APIENTRYP GetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void (QOPENGLF_APIENTRYP UniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void (QOPENGLF_APIENTRYP DrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
-    void (QOPENGLF_APIENTRYP DrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount);
-    GLsync (QOPENGLF_APIENTRYP FenceSync)(GLenum condition, GLbitfield flags);
-    GLboolean (QOPENGLF_APIENTRYP IsSync)(GLsync sync);
-    void (QOPENGLF_APIENTRYP DeleteSync)(GLsync sync);
-    GLenum (QOPENGLF_APIENTRYP ClientWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void (QOPENGLF_APIENTRYP WaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void (QOPENGLF_APIENTRYP GetInteger64v)(GLenum pname, GLint64 *data);
-    void (QOPENGLF_APIENTRYP GetSynciv)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void (QOPENGLF_APIENTRYP GetInteger64i_v)(GLenum target, GLuint index, GLint64 *data);
-    void (QOPENGLF_APIENTRYP GetBufferParameteri64v)(GLenum target, GLenum pname, GLint64 *params);
-    void (QOPENGLF_APIENTRYP GenSamplers)(GLsizei count, GLuint *samplers);
-    void (QOPENGLF_APIENTRYP DeleteSamplers)(GLsizei count, const GLuint *samplers);
-    GLboolean (QOPENGLF_APIENTRYP IsSampler)(GLuint sampler);
-    void (QOPENGLF_APIENTRYP BindSampler)(GLuint unit, GLuint sampler);
-    void (QOPENGLF_APIENTRYP SamplerParameteri)(GLuint sampler, GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP SamplerParameteriv)(GLuint sampler, GLenum pname, const GLint *param);
-    void (QOPENGLF_APIENTRYP SamplerParameterf)(GLuint sampler, GLenum pname, GLfloat param);
-    void (QOPENGLF_APIENTRYP SamplerParameterfv)(GLuint sampler, GLenum pname, const GLfloat *param);
-    void (QOPENGLF_APIENTRYP GetSamplerParameteriv)(GLuint sampler, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetSamplerParameterfv)(GLuint sampler, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP VertexAttribDivisor)(GLuint index, GLuint divisor);
-    void (QOPENGLF_APIENTRYP BindTransformFeedback)(GLenum target, GLuint id);
-    void (QOPENGLF_APIENTRYP DeleteTransformFeedbacks)(GLsizei n, const GLuint *ids);
-    void (QOPENGLF_APIENTRYP GenTransformFeedbacks)(GLsizei n, GLuint *ids);
-    GLboolean (QOPENGLF_APIENTRYP IsTransformFeedback)(GLuint id);
-    void (QOPENGLF_APIENTRYP PauseTransformFeedback)(void);
-    void (QOPENGLF_APIENTRYP ResumeTransformFeedback)(void);
-    void (QOPENGLF_APIENTRYP GetProgramBinary)(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary);
-    void (QOPENGLF_APIENTRYP ProgramBinary)(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length);
-    void (QOPENGLF_APIENTRYP ProgramParameteri)(GLuint program, GLenum pname, GLint value);
-    void (QOPENGLF_APIENTRYP InvalidateFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum *attachments);
-    void (QOPENGLF_APIENTRYP InvalidateSubFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP TexStorage2D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP TexStorage3D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-    void (QOPENGLF_APIENTRYP GetInternalformativ)(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
+#define QT_OPENGL_EXTRA_FUNCTIONS(F) \
+    F(void, ReadBuffer, (GLenum mode)) \
+    F(void, DrawRangeElements, (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices)) \
+    F(void, TexImage3D, (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)) \
+    F(void, TexSubImage3D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)) \
+    F(void, CopyTexSubImage3D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)) \
+    F(void, CompressedTexImage3D, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)) \
+    F(void, CompressedTexSubImage3D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)) \
+    F(void, GenQueries, (GLsizei n, GLuint *ids)) \
+    F(void, DeleteQueries, (GLsizei n, const GLuint *ids)) \
+    F(GLboolean, IsQuery, (GLuint id)) \
+    F(void, BeginQuery, (GLenum target, GLuint id)) \
+    F(void, EndQuery, (GLenum target)) \
+    F(void, GetQueryiv, (GLenum target, GLenum pname, GLint *params)) \
+    F(void, GetQueryObjectuiv, (GLuint id, GLenum pname, GLuint *params)) \
+    F(GLboolean, UnmapBuffer, (GLenum target)) \
+    F(void, GetBufferPointerv, (GLenum target, GLenum pname, void **params)) \
+    F(void, DrawBuffers, (GLsizei n, const GLenum *bufs)) \
+    F(void, UniformMatrix2x3fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, UniformMatrix3x2fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, UniformMatrix2x4fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, UniformMatrix4x2fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, UniformMatrix3x4fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, UniformMatrix4x3fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, BlitFramebuffer, (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)) \
+    F(void, RenderbufferStorageMultisample, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)) \
+    F(void, FramebufferTextureLayer, (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)) \
+    F(void *,MapBufferRange, (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)) \
+    F(void, FlushMappedBufferRange, (GLenum target, GLintptr offset, GLsizeiptr length)) \
+    F(void, BindVertexArray, (GLuint array)) \
+    F(void, DeleteVertexArrays, (GLsizei n, const GLuint *arrays)) \
+    F(void, GenVertexArrays, (GLsizei n, GLuint *arrays)) \
+    F(GLboolean, IsVertexArray, (GLuint array)) \
+    F(void, GetIntegeri_v, (GLenum target, GLuint index, GLint *data)) \
+    F(void, BeginTransformFeedback, (GLenum primitiveMode)) \
+    F(void, EndTransformFeedback, (void)) \
+    F(void, BindBufferRange, (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)) \
+    F(void, BindBufferBase, (GLenum target, GLuint index, GLuint buffer)) \
+    F(void, TransformFeedbackVaryings, (GLuint program, GLsizei count, const GLchar *const*varyings, GLenum bufferMode)) \
+    F(void, GetTransformFeedbackVarying, (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)) \
+    F(void, VertexAttribIPointer, (GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)) \
+    F(void, GetVertexAttribIiv, (GLuint index, GLenum pname, GLint *params)) \
+    F(void, GetVertexAttribIuiv, (GLuint index, GLenum pname, GLuint *params)) \
+    F(void, VertexAttribI4i, (GLuint index, GLint x, GLint y, GLint z, GLint w)) \
+    F(void, VertexAttribI4ui, (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)) \
+    F(void, VertexAttribI4iv, (GLuint index, const GLint *v)) \
+    F(void, VertexAttribI4uiv, (GLuint index, const GLuint *v)) \
+    F(void, GetUniformuiv, (GLuint program, GLint location, GLuint *params)) \
+    F(GLint, GetFragDataLocation, (GLuint program, const GLchar *name)) \
+    F(void, Uniform1ui, (GLint location, GLuint v0)) \
+    F(void, Uniform2ui, (GLint location, GLuint v0, GLuint v1)) \
+    F(void, Uniform3ui, (GLint location, GLuint v0, GLuint v1, GLuint v2)) \
+    F(void, Uniform4ui, (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)) \
+    F(void, Uniform1uiv, (GLint location, GLsizei count, const GLuint *value)) \
+    F(void, Uniform2uiv, (GLint location, GLsizei count, const GLuint *value)) \
+    F(void, Uniform3uiv, (GLint location, GLsizei count, const GLuint *value)) \
+    F(void, Uniform4uiv, (GLint location, GLsizei count, const GLuint *value)) \
+    F(void, ClearBufferiv, (GLenum buffer, GLint drawbuffer, const GLint *value)) \
+    F(void, ClearBufferuiv, (GLenum buffer, GLint drawbuffer, const GLuint *value)) \
+    F(void, ClearBufferfv, (GLenum buffer, GLint drawbuffer, const GLfloat *value)) \
+    F(void, ClearBufferfi, (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)) \
+    F(const GLubyte *, GetStringi, (GLenum name, GLuint index)) \
+    F(void, CopyBufferSubData, (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)) \
+    F(void, GetUniformIndices, (GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices)) \
+    F(void, GetActiveUniformsiv, (GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)) \
+    F(GLuint, GetUniformBlockIndex, (GLuint program, const GLchar *uniformBlockName)) \
+    F(void, GetActiveUniformBlockiv, (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)) \
+    F(void, GetActiveUniformBlockName, (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)) \
+    F(void, UniformBlockBinding, (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)) \
+    F(void, DrawArraysInstanced, (GLenum mode, GLint first, GLsizei count, GLsizei instancecount)) \
+    F(void, DrawElementsInstanced, (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount)) \
+    F(GLsync, FenceSync, (GLenum condition, GLbitfield flags)) \
+    F(GLboolean, IsSync, (GLsync sync)) \
+    F(void, DeleteSync, (GLsync sync)) \
+    F(GLenum, ClientWaitSync, (GLsync sync, GLbitfield flags, GLuint64 timeout)) \
+    F(void, WaitSync, (GLsync sync, GLbitfield flags, GLuint64 timeout)) \
+    F(void, GetInteger64v, (GLenum pname, GLint64 *data)) \
+    F(void, GetSynciv, (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)) \
+    F(void, GetInteger64i_v, (GLenum target, GLuint index, GLint64 *data)) \
+    F(void, GetBufferParameteri64v, (GLenum target, GLenum pname, GLint64 *params)) \
+    F(void, GenSamplers, (GLsizei count, GLuint *samplers)) \
+    F(void, DeleteSamplers, (GLsizei count, const GLuint *samplers)) \
+    F(GLboolean, IsSampler, (GLuint sampler)) \
+    F(void, BindSampler, (GLuint unit, GLuint sampler)) \
+    F(void, SamplerParameteri, (GLuint sampler, GLenum pname, GLint param)) \
+    F(void, SamplerParameteriv, (GLuint sampler, GLenum pname, const GLint *param)) \
+    F(void, SamplerParameterf, (GLuint sampler, GLenum pname, GLfloat param)) \
+    F(void, SamplerParameterfv, (GLuint sampler, GLenum pname, const GLfloat *param)) \
+    F(void, GetSamplerParameteriv, (GLuint sampler, GLenum pname, GLint *params)) \
+    F(void, GetSamplerParameterfv, (GLuint sampler, GLenum pname, GLfloat *params)) \
+    F(void, VertexAttribDivisor, (GLuint index, GLuint divisor)) \
+    F(void, BindTransformFeedback, (GLenum target, GLuint id)) \
+    F(void, DeleteTransformFeedbacks, (GLsizei n, const GLuint *ids)) \
+    F(void, GenTransformFeedbacks, (GLsizei n, GLuint *ids)) \
+    F(GLboolean, IsTransformFeedback, (GLuint id)) \
+    F(void, PauseTransformFeedback, (void)) \
+    F(void, ResumeTransformFeedback, (void)) \
+    F(void, GetProgramBinary, (GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)) \
+    F(void, ProgramBinary, (GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)) \
+    F(void, ProgramParameteri, (GLuint program, GLenum pname, GLint value)) \
+    F(void, InvalidateFramebuffer, (GLenum target, GLsizei numAttachments, const GLenum *attachments)) \
+    F(void, InvalidateSubFramebuffer, (GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)) \
+    F(void, TexStorage2D, (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)) \
+    F(void, TexStorage3D, (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)) \
+    F(void, GetInternalformativ, (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)) \
+    F(void, DispatchCompute, (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)) \
+    F(void, DispatchComputeIndirect, (GLintptr indirect)) \
+    F(void, DrawArraysIndirect, (GLenum mode, const void *indirect)) \
+    F(void, DrawElementsIndirect, (GLenum mode, GLenum type, const void *indirect)) \
+    F(void, FramebufferParameteri, (GLenum target, GLenum pname, GLint param)) \
+    F(void, GetFramebufferParameteriv, (GLenum target, GLenum pname, GLint *params)) \
+    F(void, GetProgramInterfaceiv, (GLuint program, GLenum programInterface, GLenum pname, GLint *params)) \
+    F(GLuint, GetProgramResourceIndex, (GLuint program, GLenum programInterface, const GLchar *name)) \
+    F(void, GetProgramResourceName, (GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)) \
+    F(void, GetProgramResourceiv, (GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)) \
+    F(GLint, GetProgramResourceLocation, (GLuint program, GLenum programInterface, const GLchar *name)) \
+    F(void, UseProgramStages, (GLuint pipeline, GLbitfield stages, GLuint program)) \
+    F(void, ActiveShaderProgram, (GLuint pipeline, GLuint program)) \
+    F(GLuint, CreateShaderProgramv, (GLenum type, GLsizei count, const GLchar *const*strings)) \
+    F(void, BindProgramPipeline, (GLuint pipeline)) \
+    F(void, DeleteProgramPipelines, (GLsizei n, const GLuint *pipelines)) \
+    F(void, GenProgramPipelines, (GLsizei n, GLuint *pipelines)) \
+    F(GLboolean, IsProgramPipeline, (GLuint pipeline)) \
+    F(void, GetProgramPipelineiv, (GLuint pipeline, GLenum pname, GLint *params)) \
+    F(void, ProgramUniform1i, (GLuint program, GLint location, GLint v0)) \
+    F(void, ProgramUniform2i, (GLuint program, GLint location, GLint v0, GLint v1)) \
+    F(void, ProgramUniform3i, (GLuint program, GLint location, GLint v0, GLint v1, GLint v2)) \
+    F(void, ProgramUniform4i, (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)) \
+    F(void, ProgramUniform1ui, (GLuint program, GLint location, GLuint v0)) \
+    F(void, ProgramUniform2ui, (GLuint program, GLint location, GLuint v0, GLuint v1)) \
+    F(void, ProgramUniform3ui, (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)) \
+    F(void, ProgramUniform4ui, (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)) \
+    F(void, ProgramUniform1f, (GLuint program, GLint location, GLfloat v0)) \
+    F(void, ProgramUniform2f, (GLuint program, GLint location, GLfloat v0, GLfloat v1)) \
+    F(void, ProgramUniform3f, (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)) \
+    F(void, ProgramUniform4f, (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)) \
+    F(void, ProgramUniform1iv, (GLuint program, GLint location, GLsizei count, const GLint *value)) \
+    F(void, ProgramUniform2iv, (GLuint program, GLint location, GLsizei count, const GLint *value)) \
+    F(void, ProgramUniform3iv, (GLuint program, GLint location, GLsizei count, const GLint *value)) \
+    F(void, ProgramUniform4iv, (GLuint program, GLint location, GLsizei count, const GLint *value)) \
+    F(void, ProgramUniform1uiv, (GLuint program, GLint location, GLsizei count, const GLuint *value)) \
+    F(void, ProgramUniform2uiv, (GLuint program, GLint location, GLsizei count, const GLuint *value)) \
+    F(void, ProgramUniform3uiv, (GLuint program, GLint location, GLsizei count, const GLuint *value)) \
+    F(void, ProgramUniform4uiv, (GLuint program, GLint location, GLsizei count, const GLuint *value)) \
+    F(void, ProgramUniform1fv, (GLuint program, GLint location, GLsizei count, const GLfloat *value)) \
+    F(void, ProgramUniform2fv, (GLuint program, GLint location, GLsizei count, const GLfloat *value)) \
+    F(void, ProgramUniform3fv, (GLuint program, GLint location, GLsizei count, const GLfloat *value)) \
+    F(void, ProgramUniform4fv, (GLuint program, GLint location, GLsizei count, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix2fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix3fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix4fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix2x3fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix3x2fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix2x4fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix4x2fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix3x4fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix4x3fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ValidateProgramPipeline, (GLuint pipeline)) \
+    F(void, GetProgramPipelineInfoLog, (GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)) \
+    F(void, BindImageTexture, (GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)) \
+    F(void, GetBooleani_v, (GLenum target, GLuint index, GLboolean *data)) \
+    F(void, MemoryBarrier, (GLbitfield barriers)) \
+    F(void, MemoryBarrierByRegion, (GLbitfield barriers)) \
+    F(void, TexStorage2DMultisample, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)) \
+    F(void, GetMultisamplefv, (GLenum pname, GLuint index, GLfloat *val)) \
+    F(void, SampleMaski, (GLuint maskNumber, GLbitfield mask)) \
+    F(void, GetTexLevelParameteriv, (GLenum target, GLint level, GLenum pname, GLint *params)) \
+    F(void, GetTexLevelParameterfv, (GLenum target, GLint level, GLenum pname, GLfloat *params)) \
+    F(void, BindVertexBuffer, (GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)) \
+    F(void, VertexAttribFormat, (GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)) \
+    F(void, VertexAttribIFormat, (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)) \
+    F(void, VertexAttribBinding, (GLuint attribindex, GLuint bindingindex)) \
+    F(void, VertexBindingDivisor, (GLuint bindingindex, GLuint divisor)) \
 
-    // GLES 3.1
-    void (QOPENGLF_APIENTRYP DispatchCompute)(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
-    void (QOPENGLF_APIENTRYP DispatchComputeIndirect)(GLintptr indirect);
-    void (QOPENGLF_APIENTRYP DrawArraysIndirect)(GLenum mode, const void *indirect);
-    void (QOPENGLF_APIENTRYP DrawElementsIndirect)(GLenum mode, GLenum type, const void *indirect);
-    void (QOPENGLF_APIENTRYP FramebufferParameteri)(GLenum target, GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP GetFramebufferParameteriv)(GLenum target, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetProgramInterfaceiv)(GLuint program, GLenum programInterface, GLenum pname, GLint *params);
-    GLuint (QOPENGLF_APIENTRYP GetProgramResourceIndex)(GLuint program, GLenum programInterface, const GLchar *name);
-    void (QOPENGLF_APIENTRYP GetProgramResourceName)(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name);
-    void (QOPENGLF_APIENTRYP GetProgramResourceiv)(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params);
-    GLint (QOPENGLF_APIENTRYP GetProgramResourceLocation)(GLuint program, GLenum programInterface, const GLchar *name);
-    void (QOPENGLF_APIENTRYP UseProgramStages)(GLuint pipeline, GLbitfield stages, GLuint program);
-    void (QOPENGLF_APIENTRYP ActiveShaderProgram)(GLuint pipeline, GLuint program);
-    GLuint (QOPENGLF_APIENTRYP CreateShaderProgramv)(GLenum type, GLsizei count, const GLchar *const*strings);
-    void (QOPENGLF_APIENTRYP BindProgramPipeline)(GLuint pipeline);
-    void (QOPENGLF_APIENTRYP DeleteProgramPipelines)(GLsizei n, const GLuint *pipelines);
-    void (QOPENGLF_APIENTRYP GenProgramPipelines)(GLsizei n, GLuint *pipelines);
-    GLboolean (QOPENGLF_APIENTRYP IsProgramPipeline)(GLuint pipeline);
-    void (QOPENGLF_APIENTRYP GetProgramPipelineiv)(GLuint pipeline, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP ProgramUniform1i)(GLuint program, GLint location, GLint v0);
-    void (QOPENGLF_APIENTRYP ProgramUniform2i)(GLuint program, GLint location, GLint v0, GLint v1);
-    void (QOPENGLF_APIENTRYP ProgramUniform3i)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
-    void (QOPENGLF_APIENTRYP ProgramUniform4i)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void (QOPENGLF_APIENTRYP ProgramUniform1ui)(GLuint program, GLint location, GLuint v0);
-    void (QOPENGLF_APIENTRYP ProgramUniform2ui)(GLuint program, GLint location, GLuint v0, GLuint v1);
-    void (QOPENGLF_APIENTRYP ProgramUniform3ui)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void (QOPENGLF_APIENTRYP ProgramUniform4ui)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void (QOPENGLF_APIENTRYP ProgramUniform1f)(GLuint program, GLint location, GLfloat v0);
-    void (QOPENGLF_APIENTRYP ProgramUniform2f)(GLuint program, GLint location, GLfloat v0, GLfloat v1);
-    void (QOPENGLF_APIENTRYP ProgramUniform3f)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void (QOPENGLF_APIENTRYP ProgramUniform4f)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void (QOPENGLF_APIENTRYP ProgramUniform1iv)(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform2iv)(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform3iv)(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform4iv)(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform1uiv)(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform2uiv)(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform3uiv)(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform4uiv)(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform1fv)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform2fv)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform3fv)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform4fv)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix2x3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix3x2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix2x4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix4x2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix3x4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix4x3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ValidateProgramPipeline)(GLuint pipeline);
-    void (QOPENGLF_APIENTRYP GetProgramPipelineInfoLog)(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void (QOPENGLF_APIENTRYP BindImageTexture)(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
-    void (QOPENGLF_APIENTRYP GetBooleani_v)(GLenum target, GLuint index, GLboolean *data);
-    void (QOPENGLF_APIENTRYP MemoryBarrierFunc)(GLbitfield barriers);
-    void (QOPENGLF_APIENTRYP MemoryBarrierByRegion)(GLbitfield barriers);
-    void (QOPENGLF_APIENTRYP TexStorage2DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void (QOPENGLF_APIENTRYP GetMultisamplefv)(GLenum pname, GLuint index, GLfloat *val);
-    void (QOPENGLF_APIENTRYP SampleMaski)(GLuint maskNumber, GLbitfield mask);
-    void (QOPENGLF_APIENTRYP GetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP BindVertexBuffer)(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
-    void (QOPENGLF_APIENTRYP VertexAttribFormat)(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
-    void (QOPENGLF_APIENTRYP VertexAttribIFormat)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void (QOPENGLF_APIENTRYP VertexAttribBinding)(GLuint attribindex, GLuint bindingindex);
-    void (QOPENGLF_APIENTRYP VertexBindingDivisor)(GLuint bindingindex, GLuint divisor);
+    QT_OPENGL_DECLARE(QT_OPENGL_EXTRA_FUNCTIONS)
 };
 
 // GLES 3.0 and 3.1
@@ -601,7 +625,7 @@ inline void QOpenGLExtraFunctions::glBeginQuery(GLenum target, GLuint id)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->BeginQuery(target, id);
+    d->f.BeginQuery(target, id);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -609,7 +633,7 @@ inline void QOpenGLExtraFunctions::glBeginTransformFeedback(GLenum primitiveMode
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->BeginTransformFeedback(primitiveMode);
+    d->f.BeginTransformFeedback(primitiveMode);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -617,7 +641,7 @@ inline void QOpenGLExtraFunctions::glBindBufferBase(GLenum target, GLuint index,
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->BindBufferBase(target, index, buffer);
+    d->f.BindBufferBase(target, index, buffer);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -625,7 +649,7 @@ inline void QOpenGLExtraFunctions::glBindBufferRange(GLenum target, GLuint index
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->BindBufferRange(target, index, buffer, offset, size);
+    d->f.BindBufferRange(target, index, buffer, offset, size);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -633,7 +657,7 @@ inline void QOpenGLExtraFunctions::glBindSampler(GLuint unit, GLuint sampler)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->BindSampler(unit, sampler);
+    d->f.BindSampler(unit, sampler);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -641,7 +665,7 @@ inline void QOpenGLExtraFunctions::glBindTransformFeedback(GLenum target, GLuint
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->BindTransformFeedback(target, id);
+    d->f.BindTransformFeedback(target, id);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -649,7 +673,7 @@ inline void QOpenGLExtraFunctions::glBindVertexArray(GLuint array)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->BindVertexArray(array);
+    d->f.BindVertexArray(array);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -657,7 +681,7 @@ inline void QOpenGLExtraFunctions::glBlitFramebuffer(GLint srcX0, GLint srcY0, G
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -665,7 +689,7 @@ inline void QOpenGLExtraFunctions::glClearBufferfi(GLenum buffer, GLint drawbuff
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -673,7 +697,7 @@ inline void QOpenGLExtraFunctions::glClearBufferfv(GLenum buffer, GLint drawbuff
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ClearBufferfv(buffer, drawbuffer, value);
+    d->f.ClearBufferfv(buffer, drawbuffer, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -681,7 +705,7 @@ inline void QOpenGLExtraFunctions::glClearBufferiv(GLenum buffer, GLint drawbuff
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ClearBufferiv(buffer, drawbuffer, value);
+    d->f.ClearBufferiv(buffer, drawbuffer, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -689,7 +713,7 @@ inline void QOpenGLExtraFunctions::glClearBufferuiv(GLenum buffer, GLint drawbuf
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ClearBufferuiv(buffer, drawbuffer, value);
+    d->f.ClearBufferuiv(buffer, drawbuffer, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -697,7 +721,7 @@ inline GLenum QOpenGLExtraFunctions::glClientWaitSync(GLsync sync, GLbitfield fl
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    GLenum result = d->ClientWaitSync(sync, flags, timeout);
+    GLenum result = d->f.ClientWaitSync(sync, flags, timeout);
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
 }
@@ -706,7 +730,7 @@ inline void QOpenGLExtraFunctions::glCompressedTexImage3D(GLenum target, GLint l
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -714,7 +738,7 @@ inline void QOpenGLExtraFunctions::glCompressedTexSubImage3D(GLenum target, GLin
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -722,7 +746,7 @@ inline void QOpenGLExtraFunctions::glCopyBufferSubData(GLenum readTarget, GLenum
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -730,7 +754,7 @@ inline void QOpenGLExtraFunctions::glCopyTexSubImage3D(GLenum target, GLint leve
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -738,7 +762,7 @@ inline void QOpenGLExtraFunctions::glDeleteQueries(GLsizei n, const GLuint * ids
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->DeleteQueries(n, ids);
+    d->f.DeleteQueries(n, ids);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -746,7 +770,7 @@ inline void QOpenGLExtraFunctions::glDeleteSamplers(GLsizei count, const GLuint
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->DeleteSamplers(count, samplers);
+    d->f.DeleteSamplers(count, samplers);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -754,7 +778,7 @@ inline void QOpenGLExtraFunctions::glDeleteSync(GLsync sync)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->DeleteSync(sync);
+    d->f.DeleteSync(sync);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -762,7 +786,7 @@ inline void QOpenGLExtraFunctions::glDeleteTransformFeedbacks(GLsizei n, const G
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->DeleteTransformFeedbacks(n, ids);
+    d->f.DeleteTransformFeedbacks(n, ids);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -770,7 +794,7 @@ inline void QOpenGLExtraFunctions::glDeleteVertexArrays(GLsizei n, const GLuint
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->DeleteVertexArrays(n, arrays);
+    d->f.DeleteVertexArrays(n, arrays);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -778,7 +802,7 @@ inline void QOpenGLExtraFunctions::glDrawArraysInstanced(GLenum mode, GLint firs
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->DrawArraysInstanced(mode, first, count, instancecount);
+    d->f.DrawArraysInstanced(mode, first, count, instancecount);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -786,7 +810,7 @@ inline void QOpenGLExtraFunctions::glDrawBuffers(GLsizei n, const GLenum * bufs)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->DrawBuffers(n, bufs);
+    d->f.DrawBuffers(n, bufs);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -794,7 +818,7 @@ inline void QOpenGLExtraFunctions::glDrawElementsInstanced(GLenum mode, GLsizei
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -802,7 +826,7 @@ inline void QOpenGLExtraFunctions::glDrawRangeElements(GLenum mode, GLuint start
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->DrawRangeElements(mode, start, end, count, type, indices);
+    d->f.DrawRangeElements(mode, start, end, count, type, indices);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -810,7 +834,7 @@ inline void QOpenGLExtraFunctions::glEndQuery(GLenum target)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->EndQuery(target);
+    d->f.EndQuery(target);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -818,7 +842,7 @@ inline void QOpenGLExtraFunctions::glEndTransformFeedback()
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->EndTransformFeedback();
+    d->f.EndTransformFeedback();
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -826,7 +850,7 @@ inline GLsync QOpenGLExtraFunctions::glFenceSync(GLenum condition, GLbitfield fl
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    GLsync result = d->FenceSync(condition, flags);
+    GLsync result = d->f.FenceSync(condition, flags);
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
 }
@@ -835,7 +859,7 @@ inline void QOpenGLExtraFunctions::glFlushMappedBufferRange(GLenum target, GLint
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->FlushMappedBufferRange(target, offset, length);
+    d->f.FlushMappedBufferRange(target, offset, length);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -843,7 +867,7 @@ inline void QOpenGLExtraFunctions::glFramebufferTextureLayer(GLenum target, GLen
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -851,7 +875,7 @@ inline void QOpenGLExtraFunctions::glGenQueries(GLsizei n, GLuint* ids)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GenQueries(n, ids);
+    d->f.GenQueries(n, ids);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -859,7 +883,7 @@ inline void QOpenGLExtraFunctions::glGenSamplers(GLsizei count, GLuint* samplers
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GenSamplers(count, samplers);
+    d->f.GenSamplers(count, samplers);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -867,7 +891,7 @@ inline void QOpenGLExtraFunctions::glGenTransformFeedbacks(GLsizei n, GLuint* id
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GenTransformFeedbacks(n, ids);
+    d->f.GenTransformFeedbacks(n, ids);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -875,7 +899,7 @@ inline void QOpenGLExtraFunctions::glGenVertexArrays(GLsizei n, GLuint* arrays)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GenVertexArrays(n, arrays);
+    d->f.GenVertexArrays(n, arrays);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -883,7 +907,7 @@ inline void QOpenGLExtraFunctions::glGetActiveUniformBlockName(GLuint program, G
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -891,7 +915,7 @@ inline void QOpenGLExtraFunctions::glGetActiveUniformBlockiv(GLuint program, GLu
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -899,7 +923,7 @@ inline void QOpenGLExtraFunctions::glGetActiveUniformsiv(GLuint program, GLsizei
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -907,7 +931,7 @@ inline void QOpenGLExtraFunctions::glGetBufferParameteri64v(GLenum target, GLenu
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetBufferParameteri64v(target, pname, params);
+    d->f.GetBufferParameteri64v(target, pname, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -915,7 +939,7 @@ inline void QOpenGLExtraFunctions::glGetBufferPointerv(GLenum target, GLenum pna
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetBufferPointerv(target, pname, params);
+    d->f.GetBufferPointerv(target, pname, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -923,7 +947,7 @@ inline GLint QOpenGLExtraFunctions::glGetFragDataLocation(GLuint program, const
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    GLint result = d->GetFragDataLocation(program, name);
+    GLint result = d->f.GetFragDataLocation(program, name);
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
 }
@@ -932,7 +956,7 @@ inline void QOpenGLExtraFunctions::glGetInteger64i_v(GLenum target, GLuint index
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetInteger64i_v(target, index, data);
+    d->f.GetInteger64i_v(target, index, data);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -940,7 +964,7 @@ inline void QOpenGLExtraFunctions::glGetInteger64v(GLenum pname, GLint64* data)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetInteger64v(pname, data);
+    d->f.GetInteger64v(pname, data);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -948,7 +972,7 @@ inline void QOpenGLExtraFunctions::glGetIntegeri_v(GLenum target, GLuint index,
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetIntegeri_v(target, index, data);
+    d->f.GetIntegeri_v(target, index, data);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -956,7 +980,7 @@ inline void QOpenGLExtraFunctions::glGetInternalformativ(GLenum target, GLenum i
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetInternalformativ(target, internalformat, pname, bufSize, params);
+    d->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -964,7 +988,7 @@ inline void QOpenGLExtraFunctions::glGetProgramBinary(GLuint program, GLsizei bu
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
+    d->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -972,7 +996,7 @@ inline void QOpenGLExtraFunctions::glGetQueryObjectuiv(GLuint id, GLenum pname,
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetQueryObjectuiv(id, pname, params);
+    d->f.GetQueryObjectuiv(id, pname, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -980,7 +1004,7 @@ inline void QOpenGLExtraFunctions::glGetQueryiv(GLenum target, GLenum pname, GLi
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetQueryiv(target, pname, params);
+    d->f.GetQueryiv(target, pname, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -988,7 +1012,7 @@ inline void QOpenGLExtraFunctions::glGetSamplerParameterfv(GLuint sampler, GLenu
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetSamplerParameterfv(sampler, pname, params);
+    d->f.GetSamplerParameterfv(sampler, pname, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -996,7 +1020,7 @@ inline void QOpenGLExtraFunctions::glGetSamplerParameteriv(GLuint sampler, GLenu
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetSamplerParameteriv(sampler, pname, params);
+    d->f.GetSamplerParameteriv(sampler, pname, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1004,7 +1028,7 @@ inline const GLubyte * QOpenGLExtraFunctions::glGetStringi(GLenum name, GLuint i
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    const GLubyte * result = d->GetStringi(name, index);
+    const GLubyte * result = d->f.GetStringi(name, index);
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
 }
@@ -1013,7 +1037,7 @@ inline void QOpenGLExtraFunctions::glGetSynciv(GLsync sync, GLenum pname, GLsize
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetSynciv(sync, pname, bufSize, length, values);
+    d->f.GetSynciv(sync, pname, bufSize, length, values);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1021,7 +1045,7 @@ inline void QOpenGLExtraFunctions::glGetTransformFeedbackVarying(GLuint program,
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1029,7 +1053,7 @@ inline GLuint QOpenGLExtraFunctions::glGetUniformBlockIndex(GLuint program, cons
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    GLuint result = d->GetUniformBlockIndex(program, uniformBlockName);
+    GLuint result = d->f.GetUniformBlockIndex(program, uniformBlockName);
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
 }
@@ -1038,7 +1062,7 @@ inline void QOpenGLExtraFunctions::glGetUniformIndices(GLuint program, GLsizei u
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1046,7 +1070,7 @@ inline void QOpenGLExtraFunctions::glGetUniformuiv(GLuint program, GLint locatio
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetUniformuiv(program, location, params);
+    d->f.GetUniformuiv(program, location, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1054,7 +1078,7 @@ inline void QOpenGLExtraFunctions::glGetVertexAttribIiv(GLuint index, GLenum pna
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetVertexAttribIiv(index, pname, params);
+    d->f.GetVertexAttribIiv(index, pname, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1062,7 +1086,7 @@ inline void QOpenGLExtraFunctions::glGetVertexAttribIuiv(GLuint index, GLenum pn
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetVertexAttribIuiv(index, pname, params);
+    d->f.GetVertexAttribIuiv(index, pname, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1070,7 +1094,7 @@ inline void QOpenGLExtraFunctions::glInvalidateFramebuffer(GLenum target, GLsize
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->InvalidateFramebuffer(target, numAttachments, attachments);
+    d->f.InvalidateFramebuffer(target, numAttachments, attachments);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1078,7 +1102,7 @@ inline void QOpenGLExtraFunctions::glInvalidateSubFramebuffer(GLenum target, GLs
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
+    d->f.InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1086,7 +1110,7 @@ inline GLboolean QOpenGLExtraFunctions::glIsQuery(GLuint id)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    GLboolean result = d->IsQuery(id);
+    GLboolean result = d->f.IsQuery(id);
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
 }
@@ -1095,7 +1119,7 @@ inline GLboolean QOpenGLExtraFunctions::glIsSampler(GLuint sampler)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    GLboolean result = d->IsSampler(sampler);
+    GLboolean result = d->f.IsSampler(sampler);
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
 }
@@ -1104,7 +1128,7 @@ inline GLboolean QOpenGLExtraFunctions::glIsSync(GLsync sync)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    GLboolean result = d->IsSync(sync);
+    GLboolean result = d->f.IsSync(sync);
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
 }
@@ -1113,7 +1137,7 @@ inline GLboolean QOpenGLExtraFunctions::glIsTransformFeedback(GLuint id)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    GLboolean result = d->IsTransformFeedback(id);
+    GLboolean result = d->f.IsTransformFeedback(id);
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
 }
@@ -1122,7 +1146,7 @@ inline GLboolean QOpenGLExtraFunctions::glIsVertexArray(GLuint array)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    GLboolean result = d->IsVertexArray(array);
+    GLboolean result = d->f.IsVertexArray(array);
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
 }
@@ -1131,7 +1155,7 @@ inline void * QOpenGLExtraFunctions::glMapBufferRange(GLenum target, GLintptr of
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    void *result = d->MapBufferRange(target, offset, length, access);
+    void *result = d->f.MapBufferRange(target, offset, length, access);
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
 }
@@ -1140,7 +1164,7 @@ inline void QOpenGLExtraFunctions::glPauseTransformFeedback()
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->PauseTransformFeedback();
+    d->f.PauseTransformFeedback();
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1148,7 +1172,7 @@ inline void QOpenGLExtraFunctions::glProgramBinary(GLuint program, GLenum binary
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramBinary(program, binaryFormat, binary, length);
+    d->f.ProgramBinary(program, binaryFormat, binary, length);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1156,7 +1180,7 @@ inline void QOpenGLExtraFunctions::glProgramParameteri(GLuint program, GLenum pn
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramParameteri(program, pname, value);
+    d->f.ProgramParameteri(program, pname, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1164,7 +1188,7 @@ inline void QOpenGLExtraFunctions::glReadBuffer(GLenum src)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ReadBuffer(src);
+    d->f.ReadBuffer(src);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1172,7 +1196,7 @@ inline void QOpenGLExtraFunctions::glRenderbufferStorageMultisample(GLenum targe
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1180,7 +1204,7 @@ inline void QOpenGLExtraFunctions::glResumeTransformFeedback()
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ResumeTransformFeedback();
+    d->f.ResumeTransformFeedback();
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1188,7 +1212,7 @@ inline void QOpenGLExtraFunctions::glSamplerParameterf(GLuint sampler, GLenum pn
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->SamplerParameterf(sampler, pname, param);
+    d->f.SamplerParameterf(sampler, pname, param);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1196,7 +1220,7 @@ inline void QOpenGLExtraFunctions::glSamplerParameterfv(GLuint sampler, GLenum p
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->SamplerParameterfv(sampler, pname, param);
+    d->f.SamplerParameterfv(sampler, pname, param);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1204,7 +1228,7 @@ inline void QOpenGLExtraFunctions::glSamplerParameteri(GLuint sampler, GLenum pn
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->SamplerParameteri(sampler, pname, param);
+    d->f.SamplerParameteri(sampler, pname, param);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1212,7 +1236,7 @@ inline void QOpenGLExtraFunctions::glSamplerParameteriv(GLuint sampler, GLenum p
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->SamplerParameteriv(sampler, pname, param);
+    d->f.SamplerParameteriv(sampler, pname, param);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1220,7 +1244,7 @@ inline void QOpenGLExtraFunctions::glTexImage3D(GLenum target, GLint level, GLin
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1228,7 +1252,7 @@ inline void QOpenGLExtraFunctions::glTexStorage2D(GLenum target, GLsizei levels,
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->TexStorage2D(target, levels, internalformat, width, height);
+    d->f.TexStorage2D(target, levels, internalformat, width, height);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1236,7 +1260,7 @@ inline void QOpenGLExtraFunctions::glTexStorage3D(GLenum target, GLsizei levels,
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->TexStorage3D(target, levels, internalformat, width, height, depth);
+    d->f.TexStorage3D(target, levels, internalformat, width, height, depth);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1244,7 +1268,7 @@ inline void QOpenGLExtraFunctions::glTexSubImage3D(GLenum target, GLint level, G
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1252,7 +1276,7 @@ inline void QOpenGLExtraFunctions::glTransformFeedbackVaryings(GLuint program, G
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1260,7 +1284,7 @@ inline void QOpenGLExtraFunctions::glUniform1ui(GLint location, GLuint v0)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->Uniform1ui(location, v0);
+    d->f.Uniform1ui(location, v0);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1268,7 +1292,7 @@ inline void QOpenGLExtraFunctions::glUniform1uiv(GLint location, GLsizei count,
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->Uniform1uiv(location, count, value);
+    d->f.Uniform1uiv(location, count, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1276,7 +1300,7 @@ inline void QOpenGLExtraFunctions::glUniform2ui(GLint location, GLuint v0, GLuin
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->Uniform2ui(location, v0, v1);
+    d->f.Uniform2ui(location, v0, v1);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1284,7 +1308,7 @@ inline void QOpenGLExtraFunctions::glUniform2uiv(GLint location, GLsizei count,
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->Uniform2uiv(location, count, value);
+    d->f.Uniform2uiv(location, count, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1292,7 +1316,7 @@ inline void QOpenGLExtraFunctions::glUniform3ui(GLint location, GLuint v0, GLuin
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->Uniform3ui(location, v0, v1, v2);
+    d->f.Uniform3ui(location, v0, v1, v2);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1300,7 +1324,7 @@ inline void QOpenGLExtraFunctions::glUniform3uiv(GLint location, GLsizei count,
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->Uniform3uiv(location, count, value);
+    d->f.Uniform3uiv(location, count, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1308,7 +1332,7 @@ inline void QOpenGLExtraFunctions::glUniform4ui(GLint location, GLuint v0, GLuin
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->Uniform4ui(location, v0, v1, v2, v3);
+    d->f.Uniform4ui(location, v0, v1, v2, v3);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1316,7 +1340,7 @@ inline void QOpenGLExtraFunctions::glUniform4uiv(GLint location, GLsizei count,
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->Uniform4uiv(location, count, value);
+    d->f.Uniform4uiv(location, count, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1324,7 +1348,7 @@ inline void QOpenGLExtraFunctions::glUniformBlockBinding(GLuint program, GLuint
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1332,7 +1356,7 @@ inline void QOpenGLExtraFunctions::glUniformMatrix2x3fv(GLint location, GLsizei
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->UniformMatrix2x3fv(location, count, transpose, value);
+    d->f.UniformMatrix2x3fv(location, count, transpose, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1340,7 +1364,7 @@ inline void QOpenGLExtraFunctions::glUniformMatrix2x4fv(GLint location, GLsizei
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->UniformMatrix2x4fv(location, count, transpose, value);
+    d->f.UniformMatrix2x4fv(location, count, transpose, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1348,7 +1372,7 @@ inline void QOpenGLExtraFunctions::glUniformMatrix3x2fv(GLint location, GLsizei
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->UniformMatrix3x2fv(location, count, transpose, value);
+    d->f.UniformMatrix3x2fv(location, count, transpose, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1356,7 +1380,7 @@ inline void QOpenGLExtraFunctions::glUniformMatrix3x4fv(GLint location, GLsizei
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->UniformMatrix3x4fv(location, count, transpose, value);
+    d->f.UniformMatrix3x4fv(location, count, transpose, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1364,7 +1388,7 @@ inline void QOpenGLExtraFunctions::glUniformMatrix4x2fv(GLint location, GLsizei
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->UniformMatrix4x2fv(location, count, transpose, value);
+    d->f.UniformMatrix4x2fv(location, count, transpose, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1372,7 +1396,7 @@ inline void QOpenGLExtraFunctions::glUniformMatrix4x3fv(GLint location, GLsizei
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->UniformMatrix4x3fv(location, count, transpose, value);
+    d->f.UniformMatrix4x3fv(location, count, transpose, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1380,7 +1404,7 @@ inline GLboolean QOpenGLExtraFunctions::glUnmapBuffer(GLenum target)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    GLboolean result = d->UnmapBuffer(target);
+    GLboolean result = d->f.UnmapBuffer(target);
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
 }
@@ -1389,7 +1413,7 @@ inline void QOpenGLExtraFunctions::glVertexAttribDivisor(GLuint index, GLuint di
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->VertexAttribDivisor(index, divisor);
+    d->f.VertexAttribDivisor(index, divisor);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1397,7 +1421,7 @@ inline void QOpenGLExtraFunctions::glVertexAttribI4i(GLuint index, GLint x, GLin
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->VertexAttribI4i(index, x, y, z, w);
+    d->f.VertexAttribI4i(index, x, y, z, w);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1405,7 +1429,7 @@ inline void QOpenGLExtraFunctions::glVertexAttribI4iv(GLuint index, const GLint
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->VertexAttribI4iv(index, v);
+    d->f.VertexAttribI4iv(index, v);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1413,7 +1437,7 @@ inline void QOpenGLExtraFunctions::glVertexAttribI4ui(GLuint index, GLuint x, GL
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->VertexAttribI4ui(index, x, y, z, w);
+    d->f.VertexAttribI4ui(index, x, y, z, w);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1421,7 +1445,7 @@ inline void QOpenGLExtraFunctions::glVertexAttribI4uiv(GLuint index, const GLuin
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->VertexAttribI4uiv(index, v);
+    d->f.VertexAttribI4uiv(index, v);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1429,7 +1453,7 @@ inline void QOpenGLExtraFunctions::glVertexAttribIPointer(GLuint index, GLint si
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->VertexAttribIPointer(index, size, type, stride, pointer);
+    d->f.VertexAttribIPointer(index, size, type, stride, pointer);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1437,7 +1461,7 @@ inline void QOpenGLExtraFunctions::glWaitSync(GLsync sync, GLbitfield flags, GLu
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->WaitSync(sync, flags, timeout);
+    d->f.WaitSync(sync, flags, timeout);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1445,7 +1469,7 @@ inline void QOpenGLExtraFunctions::glActiveShaderProgram(GLuint pipeline, GLuint
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ActiveShaderProgram(pipeline, program);
+    d->f.ActiveShaderProgram(pipeline, program);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1453,7 +1477,7 @@ inline void QOpenGLExtraFunctions::glBindImageTexture(GLuint unit, GLuint textur
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->BindImageTexture(unit, texture, level, layered, layer, access, format);
+    d->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1461,7 +1485,7 @@ inline void QOpenGLExtraFunctions::glBindProgramPipeline(GLuint pipeline)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->BindProgramPipeline(pipeline);
+    d->f.BindProgramPipeline(pipeline);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1469,7 +1493,7 @@ inline void QOpenGLExtraFunctions::glBindVertexBuffer(GLuint bindingindex, GLuin
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->BindVertexBuffer(bindingindex, buffer, offset, stride);
+    d->f.BindVertexBuffer(bindingindex, buffer, offset, stride);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1477,7 +1501,7 @@ inline GLuint QOpenGLExtraFunctions::glCreateShaderProgramv(GLenum type, GLsizei
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    GLuint result = d->CreateShaderProgramv(type, count, strings);
+    GLuint result = d->f.CreateShaderProgramv(type, count, strings);
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
 }
@@ -1486,7 +1510,7 @@ inline void QOpenGLExtraFunctions::glDeleteProgramPipelines(GLsizei n, const GLu
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->DeleteProgramPipelines(n, pipelines);
+    d->f.DeleteProgramPipelines(n, pipelines);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1494,7 +1518,7 @@ inline void QOpenGLExtraFunctions::glDispatchCompute(GLuint num_groups_x, GLuint
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
+    d->f.DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1502,7 +1526,7 @@ inline void QOpenGLExtraFunctions::glDispatchComputeIndirect(GLintptr indirect)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->DispatchComputeIndirect(indirect);
+    d->f.DispatchComputeIndirect(indirect);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1510,7 +1534,7 @@ inline void QOpenGLExtraFunctions::glDrawArraysIndirect(GLenum mode, const void
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->DrawArraysIndirect(mode, indirect);
+    d->f.DrawArraysIndirect(mode, indirect);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1518,7 +1542,7 @@ inline void QOpenGLExtraFunctions::glDrawElementsIndirect(GLenum mode, GLenum ty
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->DrawElementsIndirect(mode, type, indirect);
+    d->f.DrawElementsIndirect(mode, type, indirect);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1526,7 +1550,7 @@ inline void QOpenGLExtraFunctions::glFramebufferParameteri(GLenum target, GLenum
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->FramebufferParameteri(target, pname, param);
+    d->f.FramebufferParameteri(target, pname, param);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1534,7 +1558,7 @@ inline void QOpenGLExtraFunctions::glGenProgramPipelines(GLsizei n, GLuint* pipe
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GenProgramPipelines(n, pipelines);
+    d->f.GenProgramPipelines(n, pipelines);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1542,7 +1566,7 @@ inline void QOpenGLExtraFunctions::glGetBooleani_v(GLenum target, GLuint index,
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetBooleani_v(target, index, data);
+    d->f.GetBooleani_v(target, index, data);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1550,7 +1574,7 @@ inline void QOpenGLExtraFunctions::glGetFramebufferParameteriv(GLenum target, GL
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetFramebufferParameteriv(target, pname, params);
+    d->f.GetFramebufferParameteriv(target, pname, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1558,7 +1582,7 @@ inline void QOpenGLExtraFunctions::glGetMultisamplefv(GLenum pname, GLuint index
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetMultisamplefv(pname, index, val);
+    d->f.GetMultisamplefv(pname, index, val);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1566,7 +1590,7 @@ inline void QOpenGLExtraFunctions::glGetProgramInterfaceiv(GLuint program, GLenu
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetProgramInterfaceiv(program, programInterface, pname, params);
+    d->f.GetProgramInterfaceiv(program, programInterface, pname, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1574,7 +1598,7 @@ inline void QOpenGLExtraFunctions::glGetProgramPipelineInfoLog(GLuint pipeline,
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+    d->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1582,7 +1606,7 @@ inline void QOpenGLExtraFunctions::glGetProgramPipelineiv(GLuint pipeline, GLenu
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetProgramPipelineiv(pipeline, pname, params);
+    d->f.GetProgramPipelineiv(pipeline, pname, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1590,7 +1614,7 @@ inline GLuint QOpenGLExtraFunctions::glGetProgramResourceIndex(GLuint program, G
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    GLuint result = d->GetProgramResourceIndex(program, programInterface, name);
+    GLuint result = d->f.GetProgramResourceIndex(program, programInterface, name);
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
 }
@@ -1599,7 +1623,7 @@ inline GLint QOpenGLExtraFunctions::glGetProgramResourceLocation(GLuint program,
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    GLint result = d->GetProgramResourceLocation(program, programInterface, name);
+    GLint result = d->f.GetProgramResourceLocation(program, programInterface, name);
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
 }
@@ -1608,7 +1632,7 @@ inline void QOpenGLExtraFunctions::glGetProgramResourceName(GLuint program, GLen
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetProgramResourceName(program, programInterface, index, bufSize, length, name);
+    d->f.GetProgramResourceName(program, programInterface, index, bufSize, length, name);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1616,7 +1640,7 @@ inline void QOpenGLExtraFunctions::glGetProgramResourceiv(GLuint program, GLenum
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
+    d->f.GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1624,7 +1648,7 @@ inline void QOpenGLExtraFunctions::glGetTexLevelParameterfv(GLenum target, GLint
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetTexLevelParameterfv(target, level, pname, params);
+    d->f.GetTexLevelParameterfv(target, level, pname, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1632,7 +1656,7 @@ inline void QOpenGLExtraFunctions::glGetTexLevelParameteriv(GLenum target, GLint
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->GetTexLevelParameteriv(target, level, pname, params);
+    d->f.GetTexLevelParameteriv(target, level, pname, params);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1640,7 +1664,7 @@ inline GLboolean QOpenGLExtraFunctions::glIsProgramPipeline(GLuint pipeline)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    GLboolean result = d->IsProgramPipeline(pipeline);
+    GLboolean result = d->f.IsProgramPipeline(pipeline);
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
 }
@@ -1649,7 +1673,7 @@ inline void QOpenGLExtraFunctions::glMemoryBarrier(GLbitfield barriers)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->MemoryBarrierFunc(barriers);
+    d->f.MemoryBarrier(barriers);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1657,7 +1681,7 @@ inline void QOpenGLExtraFunctions::glMemoryBarrierByRegion(GLbitfield barriers)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->MemoryBarrierByRegion(barriers);
+    d->f.MemoryBarrierByRegion(barriers);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1665,7 +1689,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform1f(GLuint program, GLint loca
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform1f(program, location, v0);
+    d->f.ProgramUniform1f(program, location, v0);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1673,7 +1697,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform1fv(GLuint program, GLint loc
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform1fv(program, location, count, value);
+    d->f.ProgramUniform1fv(program, location, count, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1681,7 +1705,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform1i(GLuint program, GLint loca
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform1i(program, location, v0);
+    d->f.ProgramUniform1i(program, location, v0);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1689,7 +1713,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform1iv(GLuint program, GLint loc
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform1iv(program, location, count, value);
+    d->f.ProgramUniform1iv(program, location, count, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1697,7 +1721,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform1ui(GLuint program, GLint loc
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform1ui(program, location, v0);
+    d->f.ProgramUniform1ui(program, location, v0);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1705,7 +1729,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform1uiv(GLuint program, GLint lo
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform1uiv(program, location, count, value);
+    d->f.ProgramUniform1uiv(program, location, count, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1713,7 +1737,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform2f(GLuint program, GLint loca
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform2f(program, location, v0, v1);
+    d->f.ProgramUniform2f(program, location, v0, v1);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1721,7 +1745,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform2fv(GLuint program, GLint loc
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform2fv(program, location, count, value);
+    d->f.ProgramUniform2fv(program, location, count, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1729,7 +1753,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform2i(GLuint program, GLint loca
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform2i(program, location, v0, v1);
+    d->f.ProgramUniform2i(program, location, v0, v1);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1737,7 +1761,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform2iv(GLuint program, GLint loc
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform2iv(program, location, count, value);
+    d->f.ProgramUniform2iv(program, location, count, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1745,7 +1769,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform2ui(GLuint program, GLint loc
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform2ui(program, location, v0, v1);
+    d->f.ProgramUniform2ui(program, location, v0, v1);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1753,7 +1777,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform2uiv(GLuint program, GLint lo
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform2uiv(program, location, count, value);
+    d->f.ProgramUniform2uiv(program, location, count, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1761,7 +1785,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform3f(GLuint program, GLint loca
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform3f(program, location, v0, v1, v2);
+    d->f.ProgramUniform3f(program, location, v0, v1, v2);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1769,7 +1793,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform3fv(GLuint program, GLint loc
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform3fv(program, location, count, value);
+    d->f.ProgramUniform3fv(program, location, count, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1777,7 +1801,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform3i(GLuint program, GLint loca
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform3i(program, location, v0, v1, v2);
+    d->f.ProgramUniform3i(program, location, v0, v1, v2);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1785,7 +1809,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform3iv(GLuint program, GLint loc
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform3iv(program, location, count, value);
+    d->f.ProgramUniform3iv(program, location, count, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1793,7 +1817,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform3ui(GLuint program, GLint loc
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform3ui(program, location, v0, v1, v2);
+    d->f.ProgramUniform3ui(program, location, v0, v1, v2);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1801,7 +1825,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform3uiv(GLuint program, GLint lo
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform3uiv(program, location, count, value);
+    d->f.ProgramUniform3uiv(program, location, count, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1809,7 +1833,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform4f(GLuint program, GLint loca
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform4f(program, location, v0, v1, v2, v3);
+    d->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1817,7 +1841,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform4fv(GLuint program, GLint loc
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform4fv(program, location, count, value);
+    d->f.ProgramUniform4fv(program, location, count, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1825,7 +1849,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform4i(GLuint program, GLint loca
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform4i(program, location, v0, v1, v2, v3);
+    d->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1833,7 +1857,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform4iv(GLuint program, GLint loc
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform4iv(program, location, count, value);
+    d->f.ProgramUniform4iv(program, location, count, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1841,7 +1865,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform4ui(GLuint program, GLint loc
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform4ui(program, location, v0, v1, v2, v3);
+    d->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1849,7 +1873,7 @@ inline void QOpenGLExtraFunctions::glProgramUniform4uiv(GLuint program, GLint lo
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniform4uiv(program, location, count, value);
+    d->f.ProgramUniform4uiv(program, location, count, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1857,7 +1881,7 @@ inline void QOpenGLExtraFunctions::glProgramUniformMatrix2fv(GLuint program, GLi
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniformMatrix2fv(program, location, count, transpose, value);
+    d->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1865,7 +1889,7 @@ inline void QOpenGLExtraFunctions::glProgramUniformMatrix2x3fv(GLuint program, G
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
+    d->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1873,7 +1897,7 @@ inline void QOpenGLExtraFunctions::glProgramUniformMatrix2x4fv(GLuint program, G
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
+    d->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1881,7 +1905,7 @@ inline void QOpenGLExtraFunctions::glProgramUniformMatrix3fv(GLuint program, GLi
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniformMatrix3fv(program, location, count, transpose, value);
+    d->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1889,7 +1913,7 @@ inline void QOpenGLExtraFunctions::glProgramUniformMatrix3x2fv(GLuint program, G
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
+    d->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1897,7 +1921,7 @@ inline void QOpenGLExtraFunctions::glProgramUniformMatrix3x4fv(GLuint program, G
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
+    d->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1905,7 +1929,7 @@ inline void QOpenGLExtraFunctions::glProgramUniformMatrix4fv(GLuint program, GLi
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniformMatrix4fv(program, location, count, transpose, value);
+    d->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1913,7 +1937,7 @@ inline void QOpenGLExtraFunctions::glProgramUniformMatrix4x2fv(GLuint program, G
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
+    d->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1921,7 +1945,7 @@ inline void QOpenGLExtraFunctions::glProgramUniformMatrix4x3fv(GLuint program, G
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
+    d->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1929,7 +1953,7 @@ inline void QOpenGLExtraFunctions::glSampleMaski(GLuint maskNumber, GLbitfield m
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->SampleMaski(maskNumber, mask);
+    d->f.SampleMaski(maskNumber, mask);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1937,7 +1961,7 @@ inline void QOpenGLExtraFunctions::glTexStorage2DMultisample(GLenum target, GLsi
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d->f.TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1945,7 +1969,7 @@ inline void QOpenGLExtraFunctions::glUseProgramStages(GLuint pipeline, GLbitfiel
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->UseProgramStages(pipeline, stages, program);
+    d->f.UseProgramStages(pipeline, stages, program);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1953,7 +1977,7 @@ inline void QOpenGLExtraFunctions::glValidateProgramPipeline(GLuint pipeline)
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->ValidateProgramPipeline(pipeline);
+    d->f.ValidateProgramPipeline(pipeline);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1961,7 +1985,7 @@ inline void QOpenGLExtraFunctions::glVertexAttribBinding(GLuint attribindex, GLu
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->VertexAttribBinding(attribindex, bindingindex);
+    d->f.VertexAttribBinding(attribindex, bindingindex);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1969,7 +1993,7 @@ inline void QOpenGLExtraFunctions::glVertexAttribFormat(GLuint attribindex, GLin
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
+    d->f.VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1977,7 +2001,7 @@ inline void QOpenGLExtraFunctions::glVertexAttribIFormat(GLuint attribindex, GLi
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->VertexAttribIFormat(attribindex, size, type, relativeoffset);
+    d->f.VertexAttribIFormat(attribindex, size, type, relativeoffset);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
@@ -1985,12 +2009,20 @@ inline void QOpenGLExtraFunctions::glVertexBindingDivisor(GLuint bindingindex, G
 {
     Q_D(QOpenGLExtraFunctions);
     Q_ASSERT(QOpenGLExtraFunctions::isInitialized(d));
-    d->VertexBindingDivisor(bindingindex, divisor);
+    d->f.VertexBindingDivisor(bindingindex, divisor);
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
 QT_END_NAMESPACE
 
+#undef QT_OPENGL_DECLARE_FUNCTIONS
+#undef QT_OPENGL_COUNT_FUNCTIONS
+#undef QT_OPENGL_DECLARE
+
+#ifdef Q_OS_WIN
+#pragma pop_macro("MemoryBarrier")
+#endif
+
 #endif // QT_NO_OPENGL
 
 #endif
diff --git a/src/gui/opengl/qopenglfunctions.cpp b/src/gui/opengl/qopenglfunctions.cpp
index b55c8786232..ea5a8e9252d 100644
--- a/src/gui/opengl/qopenglfunctions.cpp
+++ b/src/gui/opengl/qopenglfunctions.cpp
@@ -47,10 +47,6 @@
 #include <qpa/qplatformintegration.h>
 #include <QtCore/qloggingcategory.h>
 
-#ifdef Q_OS_IOS
-#include <dlfcn.h>
-#endif
-
 #ifndef GL_FRAMEBUFFER_SRGB_CAPABLE_EXT
 #define GL_FRAMEBUFFER_SRGB_CAPABLE_EXT   0x8DBA
 #endif
@@ -59,6 +55,23 @@ QT_BEGIN_NAMESPACE
 
 Q_LOGGING_CATEGORY(lcGLES3, "qt.opengl.es3")
 
+
+#define QT_OPENGL_COUNT_FUNCTIONS(ret, name, args) +1
+#define QT_OPENGL_FUNCTION_NAMES(ret, name, args) \
+    "gl"#name"\0"
+#define QT_OPENGL_FLAGS(ret, name, args) \
+    0,
+#define QT_OPENGL_IMPLEMENT(CLASS, FUNCTIONS) \
+void CLASS::init(QOpenGLContext *context) \
+{ \
+    const char *names = FUNCTIONS(QT_OPENGL_FUNCTION_NAMES); \
+    const char *name = names; \
+    for (int i = 0; i < FUNCTIONS(QT_OPENGL_COUNT_FUNCTIONS); ++i) { \
+        functions[i] = QT_PREPEND_NAMESPACE(getProcAddress(context, name)); \
+        name += strlen(name) + 1; \
+    } \
+}
+
 /*!
     \class QOpenGLFunctions
     \brief The QOpenGLFunctions class provides cross-platform access to the OpenGL ES 2.0 API.
@@ -260,7 +273,7 @@ QOpenGLFunctions::QOpenGLFunctions(QOpenGLContext *context)
     if (context && QOpenGLContextGroup::currentContextGroup() == context->shareGroup())
         d_ptr = qt_gl_functions(context);
     else
-        qWarning() << "QOpenGLFunctions created with non-current context";
+        qWarning("QOpenGLFunctions created with non-current context");
 }
 
 QOpenGLExtensions::QOpenGLExtensions()
@@ -2085,838 +2098,68 @@ void QOpenGLFunctions::initializeOpenGLFunctions()
 
 namespace {
 
-enum ResolvePolicy
+// this function tries hard to get the opengl function we're looking for by also
+// trying to resolve it with some of the common extensions if the generic name
+// can't be found.
+static QFunctionPointer getProcAddress(QOpenGLContext *context, const char *funcName)
 {
-    ResolveOES = 0x1,
-    ResolveEXT = 0x2,
-    ResolveANGLE = 0x4,
-    ResolveNV = 0x8
-};
+    QFunctionPointer function = context->getProcAddress(funcName);
 
-template <typename Base, typename FuncType, int Policy, typename ReturnType>
-class Resolver
-{
-public:
-    Resolver(FuncType Base::*func, FuncType fallback, const char *name)
-        : funcPointerName(func)
-        , fallbackFuncPointer(fallback)
-        , funcName(name)
-    {
+    static const struct {
+        const char *name;
+        int len; // includes trailing \0
+    } extensions[] = {
+        { "ARB", 4 },
+        { "OES", 4 },
+        { "EXT", 4 },
+        { "ANGLE", 6 },
+        { "NV", 3 },
+    };
+
+    if (!function) {
+        char fn[512];
+        size_t size = strlen(funcName);
+        Q_ASSERT(size < 500);
+        memcpy(fn, funcName, size);
+        char *ext = fn + size;
+
+        for (const auto &e : extensions) {
+            memcpy(ext, e.name, e.len);
+            function = context->getProcAddress(fn);
+            if (function)
+                break;
+        }
     }
 
-    ReturnType operator()();
-
-    template <typename P1>
-    ReturnType operator()(P1 p1);
-
-    template <typename P1, typename P2>
-    ReturnType operator()(P1 p1, P2 p2);
-
-    template <typename P1, typename P2, typename P3>
-    ReturnType operator()(P1 p1, P2 p2, P3 p3);
-
-    template <typename P1, typename P2, typename P3, typename P4>
-    ReturnType operator()(P1 p1, P2 p2, P3 p3, P4 p4);
-
-    template <typename P1, typename P2, typename P3, typename P4, typename P5>
-    ReturnType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5);
-
-    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
-    ReturnType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6);
-
-    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
-    ReturnType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7);
-
-    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
-    ReturnType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8);
-
-    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
-    ReturnType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9);
-
-    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
-    ReturnType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10);
-
-    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
-    ReturnType operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11);
-
-private:
-    FuncType Base::*funcPointerName;
-    FuncType fallbackFuncPointer;
-    QByteArray funcName;
-};
-
-template <typename Base, typename FuncType, int Policy>
-class Resolver<Base, FuncType, Policy, void>
-{
-public:
-    Resolver(FuncType Base::*func, FuncType fallback, const char *name)
-        : funcPointerName(func)
-        , fallbackFuncPointer(fallback)
-        , funcName(name)
-    {
-    }
-
-    void operator()();
-
-    template <typename P1>
-    void operator()(P1 p1);
-
-    template <typename P1, typename P2>
-    void operator()(P1 p1, P2 p2);
-
-    template <typename P1, typename P2, typename P3>
-    void operator()(P1 p1, P2 p2, P3 p3);
-
-    template <typename P1, typename P2, typename P3, typename P4>
-    void operator()(P1 p1, P2 p2, P3 p3, P4 p4);
-
-    template <typename P1, typename P2, typename P3, typename P4, typename P5>
-    void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5);
-
-    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
-    void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6);
-
-    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
-    void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7);
-
-    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
-    void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8);
-
-    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
-    void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9);
-
-    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
-    void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10);
-
-    template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
-    void operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11);
-
-private:
-    FuncType Base::*funcPointerName;
-    FuncType fallbackFuncPointer;
-    QByteArray funcName;
-};
-
-#define RESOLVER_COMMON \
-    QOpenGLContext *context = QOpenGLContext::currentContext(); \
-    Base *funcs = qt_gl_functions(context); \
- \
-    FuncType old = funcs->*funcPointerName; \
- \
-    funcs->*funcPointerName = (FuncType)context->getProcAddress(funcName); \
- \
-    if ((Policy & ResolveOES) && !(funcs->*funcPointerName)) \
-        funcs->*funcPointerName = (FuncType)context->getProcAddress(funcName + "OES"); \
- \
-    if (!(funcs->*funcPointerName)) \
-        funcs->*funcPointerName = (FuncType)context->getProcAddress(funcName + "ARB"); \
- \
-    if ((Policy & ResolveEXT) && !(funcs->*funcPointerName)) \
-        funcs->*funcPointerName = (FuncType)context->getProcAddress(funcName + "EXT"); \
- \
-    if ((Policy & ResolveANGLE) && !(funcs->*funcPointerName)) \
-        funcs->*funcPointerName = (FuncType)context->getProcAddress(funcName + "ANGLE"); \
- \
-    if ((Policy & ResolveNV) && !(funcs->*funcPointerName)) \
-        funcs->*funcPointerName = (FuncType)context->getProcAddress(funcName + "NV");
-
-#define RESOLVER_COMMON_NON_VOID \
-    RESOLVER_COMMON \
- \
-    if (!(funcs->*funcPointerName)) { \
-        if (fallbackFuncPointer) { \
-            funcs->*funcPointerName = fallbackFuncPointer; \
-        } else { \
-            funcs->*funcPointerName = old; \
-            return ReturnType(); \
-        } \
-    }
-
-#define RESOLVER_COMMON_VOID \
-    RESOLVER_COMMON \
- \
-    if (!(funcs->*funcPointerName)) { \
-        if (fallbackFuncPointer) { \
-            funcs->*funcPointerName = fallbackFuncPointer; \
-        } else { \
-            funcs->*funcPointerName = old; \
-            return; \
-        } \
-    }
-
-template <typename Base, typename FuncType, int Policy, typename ReturnType>
-ReturnType Resolver<Base, FuncType, Policy, ReturnType>::operator()()
-{
-    RESOLVER_COMMON_NON_VOID
-
-    return (funcs->*funcPointerName)();
+    return function;
 }
 
-template <typename Base, typename FuncType, int Policy, typename ReturnType> template <typename P1>
-ReturnType Resolver<Base, FuncType, Policy, ReturnType>::operator()(P1 p1)
+template <typename Func>
+Func resolve(QOpenGLContext *context, const char *name, Func)
 {
-    RESOLVER_COMMON_NON_VOID
-
-    return (funcs->*funcPointerName)(p1);
+    return reinterpret_cast<Func>(getProcAddress(context, name));
 }
 
-template <typename Base, typename FuncType, int Policy, typename ReturnType> template <typename P1, typename P2>
-ReturnType Resolver<Base, FuncType, Policy, ReturnType>::operator()(P1 p1, P2 p2)
-{
-    RESOLVER_COMMON_NON_VOID
-
-    return (funcs->*funcPointerName)(p1, p2);
 }
 
-template <typename Base, typename FuncType, int Policy, typename ReturnType> template <typename P1, typename P2, typename P3>
-ReturnType Resolver<Base, FuncType, Policy, ReturnType>::operator()(P1 p1, P2 p2, P3 p3)
-{
-    RESOLVER_COMMON_NON_VOID
-
-    return (funcs->*funcPointerName)(p1, p2, p3);
-}
-
-template <typename Base, typename FuncType, int Policy, typename ReturnType> template <typename P1, typename P2, typename P3, typename P4>
-ReturnType Resolver<Base, FuncType, Policy, ReturnType>::operator()(P1 p1, P2 p2, P3 p3, P4 p4)
-{
-    RESOLVER_COMMON_NON_VOID
-
-    return (funcs->*funcPointerName)(p1, p2, p3, p4);
-}
-
-template <typename Base, typename FuncType, int Policy, typename ReturnType> template <typename P1, typename P2, typename P3, typename P4, typename P5>
-ReturnType Resolver<Base, FuncType, Policy, ReturnType>::operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
-{
-    RESOLVER_COMMON_NON_VOID
-
-    return (funcs->*funcPointerName)(p1, p2, p3, p4, p5);
-}
-
-template <typename Base, typename FuncType, int Policy, typename ReturnType> template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
-ReturnType Resolver<Base, FuncType, Policy, ReturnType>::operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
-{
-    RESOLVER_COMMON_NON_VOID
-
-    return (funcs->*funcPointerName)(p1, p2, p3, p4, p5, p6);
-}
-
-template <typename Base, typename FuncType, int Policy, typename ReturnType> template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
-ReturnType Resolver<Base, FuncType, Policy, ReturnType>::operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7)
-{
-    RESOLVER_COMMON_NON_VOID
-
-    return (funcs->*funcPointerName)(p1, p2, p3, p4, p5, p6, p7);
-}
-
-template <typename Base, typename FuncType, int Policy, typename ReturnType> template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
-ReturnType Resolver<Base, FuncType, Policy, ReturnType>::operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8)
-{
-    RESOLVER_COMMON_NON_VOID
-
-    return (funcs->*funcPointerName)(p1, p2, p3, p4, p5, p6, p7, p8);
-}
-
-template <typename Base, typename FuncType, int Policy, typename ReturnType> template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
-ReturnType Resolver<Base, FuncType, Policy, ReturnType>::operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9)
-{
-    RESOLVER_COMMON_NON_VOID
-
-    return (funcs->*funcPointerName)(p1, p2, p3, p4, p5, p6, p7, p8, p9);
-}
-
-template <typename Base, typename FuncType, int Policy, typename ReturnType> template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
-ReturnType Resolver<Base, FuncType, Policy, ReturnType>::operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10)
-{
-    RESOLVER_COMMON_NON_VOID
-
-    return (funcs->*funcPointerName)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
-}
-
-template <typename Base, typename FuncType, int Policy>
-void Resolver<Base, FuncType, Policy, void>::operator()()
-{
-    RESOLVER_COMMON_VOID
-
-    (funcs->*funcPointerName)();
-}
-
-template <typename Base, typename FuncType, int Policy> template <typename P1>
-void Resolver<Base, FuncType, Policy, void>::operator()(P1 p1)
-{
-    RESOLVER_COMMON_VOID
-
-    (funcs->*funcPointerName)(p1);
-}
-
-template <typename Base, typename FuncType, int Policy> template <typename P1, typename P2>
-void Resolver<Base, FuncType, Policy, void>::operator()(P1 p1, P2 p2)
-{
-    RESOLVER_COMMON_VOID
-
-    (funcs->*funcPointerName)(p1, p2);
-}
-
-template <typename Base, typename FuncType, int Policy> template <typename P1, typename P2, typename P3>
-void Resolver<Base, FuncType, Policy, void>::operator()(P1 p1, P2 p2, P3 p3)
-{
-    RESOLVER_COMMON_VOID
-
-    (funcs->*funcPointerName)(p1, p2, p3);
-}
-
-template <typename Base, typename FuncType, int Policy> template <typename P1, typename P2, typename P3, typename P4>
-void Resolver<Base, FuncType, Policy, void>::operator()(P1 p1, P2 p2, P3 p3, P4 p4)
-{
-    RESOLVER_COMMON_VOID
-
-    (funcs->*funcPointerName)(p1, p2, p3, p4);
-}
-
-template <typename Base, typename FuncType, int Policy> template <typename P1, typename P2, typename P3, typename P4, typename P5>
-void Resolver<Base, FuncType, Policy, void>::operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
-{
-    RESOLVER_COMMON_VOID
-
-    (funcs->*funcPointerName)(p1, p2, p3, p4, p5);
-}
-
-template <typename Base, typename FuncType, int Policy> template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6>
-void Resolver<Base, FuncType, Policy, void>::operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6)
-{
-    RESOLVER_COMMON_VOID
-
-    (funcs->*funcPointerName)(p1, p2, p3, p4, p5, p6);
-}
-
-template <typename Base, typename FuncType, int Policy> template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7>
-void Resolver<Base, FuncType, Policy, void>::operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7)
-{
-    RESOLVER_COMMON_VOID
-
-    (funcs->*funcPointerName)(p1, p2, p3, p4, p5, p6, p7);
-}
-
-template <typename Base, typename FuncType, int Policy> template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8>
-void Resolver<Base, FuncType, Policy, void>::operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8)
-{
-    RESOLVER_COMMON_VOID
-
-    (funcs->*funcPointerName)(p1, p2, p3, p4, p5, p6, p7, p8);
-}
-
-template <typename Base, typename FuncType, int Policy> template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9>
-void Resolver<Base, FuncType, Policy, void>::operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9)
-{
-    RESOLVER_COMMON_VOID
-
-    (funcs->*funcPointerName)(p1, p2, p3, p4, p5, p6, p7, p8, p9);
-}
-
-template <typename Base, typename FuncType, int Policy> template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10>
-void Resolver<Base, FuncType, Policy, void>::operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10)
-{
-    RESOLVER_COMMON_VOID
-
-    (funcs->*funcPointerName)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10);
-}
-
-template <typename Base, typename FuncType, int Policy> template <typename P1, typename P2, typename P3, typename P4, typename P5, typename P6, typename P7, typename P8, typename P9, typename P10, typename P11>
-void Resolver<Base, FuncType, Policy, void>::operator()(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11)
-{
-    RESOLVER_COMMON_VOID
-
-    (funcs->*funcPointerName)(p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11);
-}
-
-template <typename ReturnType, int Policy, typename Base, typename FuncType>
-Resolver<Base, FuncType, Policy, ReturnType> functionResolverWithFallback(FuncType Base::*func, FuncType fallback, const char *name)
-{
-    return Resolver<Base, FuncType, Policy, ReturnType>(func, fallback, name);
-}
-
-template <typename ReturnType, int Policy, typename Base, typename FuncType>
-Resolver<Base, FuncType, Policy, ReturnType> functionResolver(FuncType Base::*func, const char *name)
-{
-    return Resolver<Base, FuncType, Policy, ReturnType>(func, 0, name);
-}
-
-} // namespace
-
-#define RESOLVE_FUNC(RETURN_TYPE, POLICY, NAME) \
-    return functionResolver<RETURN_TYPE, POLICY>(&QOpenGLExtensionsPrivate::NAME, "gl" #NAME)
-
-#define RESOLVE_FUNC_VOID(POLICY, NAME) \
-    functionResolver<void, POLICY>(&QOpenGLExtensionsPrivate::NAME, "gl" #NAME)
-
-#define RESOLVE_FUNC_SPECIAL(RETURN_TYPE, POLICY, NAME) \
-    return functionResolverWithFallback<RETURN_TYPE, POLICY>(&QOpenGLExtensionsPrivate::NAME, qopenglfSpecial##NAME, "gl" #NAME)
-
-#define RESOLVE_FUNC_SPECIAL_VOID(POLICY, NAME) \
-    functionResolverWithFallback<void, POLICY>(&QOpenGLExtensionsPrivate::NAME, qopenglfSpecial##NAME, "gl" #NAME)
+#define RESOLVE(name) \
+    resolve(context, "gl"#name, name)
 
 #ifndef QT_OPENGL_ES_2
 
-// GLES2 + OpenGL1 common subset. These are normally not resolvable,
-// but the underlying platform code may hide this limitation.
-
-static void QOPENGLF_APIENTRY qopenglfResolveBindTexture(GLenum target, GLuint texture)
-{
-    RESOLVE_FUNC_VOID(0, BindTexture)(target, texture);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBlendFunc(GLenum sfactor, GLenum dfactor)
-{
-    RESOLVE_FUNC_VOID(0, BlendFunc)(sfactor, dfactor);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveClear(GLbitfield mask)
-{
-    RESOLVE_FUNC_VOID(0, Clear)(mask);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
-{
-    RESOLVE_FUNC_VOID(0, ClearColor)(red, green, blue, alpha);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveClearDepthf(GLclampf depth)
-{
-    if (QOpenGLContext::currentContext()->isOpenGLES()) {
-        RESOLVE_FUNC_VOID(0, ClearDepthf)(depth);
-    } else {
-        RESOLVE_FUNC_VOID(0, ClearDepth)((GLdouble) depth);
-    }
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveClearStencil(GLint s)
-{
-    RESOLVE_FUNC_VOID(0, ClearStencil)(s);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
-{
-    RESOLVE_FUNC_VOID(0, ColorMask)(red, green, blue, alpha);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
-{
-    RESOLVE_FUNC_VOID(0, CopyTexImage2D)(target, level, internalformat, x, y, width, height, border);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    RESOLVE_FUNC_VOID(0, CopyTexSubImage2D)(target, level, xoffset, yoffset, x, y, width, height);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveCullFace(GLenum mode)
-{
-    RESOLVE_FUNC_VOID(0, CullFace)(mode);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDeleteTextures(GLsizei n, const GLuint* textures)
-{
-    RESOLVE_FUNC_VOID(0, DeleteTextures)(n, textures);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDepthFunc(GLenum func)
-{
-    RESOLVE_FUNC_VOID(0, DepthFunc)(func);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDepthMask(GLboolean flag)
-{
-    RESOLVE_FUNC_VOID(0, DepthMask)(flag);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDepthRangef(GLclampf zNear, GLclampf zFar)
-{
-    if (QOpenGLContext::currentContext()->isOpenGLES()) {
-        RESOLVE_FUNC_VOID(0, DepthRangef)(zNear, zFar);
-    } else {
-        RESOLVE_FUNC_VOID(0, DepthRange)((GLdouble) zNear, (GLdouble) zFar);
-    }
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDisable(GLenum cap)
-{
-    RESOLVE_FUNC_VOID(0, Disable)(cap);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDrawArrays(GLenum mode, GLint first, GLsizei count)
-{
-    RESOLVE_FUNC_VOID(0, DrawArrays)(mode, first, count);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)
-{
-    RESOLVE_FUNC_VOID(0, DrawElements)(mode, count, type, indices);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveEnable(GLenum cap)
-{
-    RESOLVE_FUNC_VOID(0, Enable)(cap);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveFinish()
-{
-    RESOLVE_FUNC_VOID(0, Finish)();
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveFlush()
-{
-    RESOLVE_FUNC_VOID(0, Flush)();
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveFrontFace(GLenum mode)
-{
-    RESOLVE_FUNC_VOID(0, FrontFace)(mode);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGenTextures(GLsizei n, GLuint* textures)
-{
-    RESOLVE_FUNC_VOID(0, GenTextures)(n, textures);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetBooleanv(GLenum pname, GLboolean* params)
-{
-    RESOLVE_FUNC_VOID(0, GetBooleanv)(pname, params);
-}
-
-static GLenum QOPENGLF_APIENTRY qopenglfResolveGetError()
-{
-    RESOLVE_FUNC(GLenum, 0, GetError)();
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetFloatv(GLenum pname, GLfloat* params)
-{
-    RESOLVE_FUNC_VOID(0, GetFloatv)(pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetIntegerv(GLenum pname, GLint* params)
-{
-    RESOLVE_FUNC_VOID(0, GetIntegerv)(pname, params);
-}
-
-static const GLubyte * QOPENGLF_APIENTRY qopenglfResolveGetString(GLenum name)
-{
-    RESOLVE_FUNC(const GLubyte *, 0, GetString)(name);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetTexParameterfv(GLenum target, GLenum pname, GLfloat* params)
-{
-    RESOLVE_FUNC_VOID(0, GetTexParameterfv)(target, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetTexParameteriv(GLenum target, GLenum pname, GLint* params)
-{
-    RESOLVE_FUNC_VOID(0, GetTexParameteriv)(target, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveHint(GLenum target, GLenum mode)
-{
-    RESOLVE_FUNC_VOID(0, Hint)(target, mode);
-}
-
-static GLboolean QOPENGLF_APIENTRY qopenglfResolveIsEnabled(GLenum cap)
-{
-    RESOLVE_FUNC(GLboolean, 0, IsEnabled)(cap);
-}
-
-static GLboolean QOPENGLF_APIENTRY qopenglfResolveIsTexture(GLuint texture)
-{
-    RESOLVE_FUNC(GLboolean, 0, IsTexture)(texture);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveLineWidth(GLfloat width)
-{
-    RESOLVE_FUNC_VOID(0, LineWidth)(width);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolvePixelStorei(GLenum pname, GLint param)
-{
-    RESOLVE_FUNC_VOID(0, PixelStorei)(pname, param);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolvePolygonOffset(GLfloat factor, GLfloat units)
-{
-    RESOLVE_FUNC_VOID(0, PolygonOffset)(factor, units);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)
-{
-    RESOLVE_FUNC_VOID(0, ReadPixels)(x, y, width, height, format, type, pixels);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveScissor(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    RESOLVE_FUNC_VOID(0, Scissor)(x, y, width, height);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveStencilFunc(GLenum func, GLint ref, GLuint mask)
-{
-    RESOLVE_FUNC_VOID(0, StencilFunc)(func, ref, mask);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveStencilMask(GLuint mask)
-{
-    RESOLVE_FUNC_VOID(0, StencilMask)(mask);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
-{
-    RESOLVE_FUNC_VOID(0, StencilOp)(fail, zfail, zpass);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels)
-{
-    RESOLVE_FUNC_VOID(0, TexImage2D)(target, level, internalformat, width, height, border, format, type, pixels);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveTexParameterf(GLenum target, GLenum pname, GLfloat param)
-{
-    RESOLVE_FUNC_VOID(0, TexParameterf)(target, pname, param);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveTexParameterfv(GLenum target, GLenum pname, const GLfloat* params)
-{
-    RESOLVE_FUNC_VOID(0, TexParameterfv)(target, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveTexParameteri(GLenum target, GLenum pname, GLint param)
-{
-    RESOLVE_FUNC_VOID(0, TexParameteri)(target, pname, param);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveTexParameteriv(GLenum target, GLenum pname, const GLint* params)
-{
-    RESOLVE_FUNC_VOID(0, TexParameteriv)(target, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)
-{
-    RESOLVE_FUNC_VOID(0, TexSubImage2D)(target, level, xoffset, yoffset, width, height, format, type, pixels);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveViewport(GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    RESOLVE_FUNC_VOID(0, Viewport)(x, y, width, height);
-}
-
-// GL(ES)2
-
-static void QOPENGLF_APIENTRY qopenglfResolveActiveTexture(GLenum texture)
-{
-    RESOLVE_FUNC_VOID(0, ActiveTexture)(texture);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveAttachShader(GLuint program, GLuint shader)
-{
-    RESOLVE_FUNC_VOID(0, AttachShader)(program, shader);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBindAttribLocation(GLuint program, GLuint index, const char* name)
-{
-    RESOLVE_FUNC_VOID(0, BindAttribLocation)(program, index, name);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBindBuffer(GLenum target, GLuint buffer)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, BindBuffer)(target, buffer);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBindFramebuffer(GLenum target, GLuint framebuffer)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, BindFramebuffer)(target, framebuffer);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBindRenderbuffer(GLenum target, GLuint renderbuffer)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, BindRenderbuffer)(target, renderbuffer);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, BlendColor)(red, green, blue, alpha);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBlendEquation(GLenum mode)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, BlendEquation)(mode);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, BlendEquationSeparate)(modeRGB, modeAlpha);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, BlendFuncSeparate)(srcRGB, dstRGB, srcAlpha, dstAlpha);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBufferData(GLenum target, qopengl_GLsizeiptr size, const void* data, GLenum usage)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, BufferData)(target, size, data, usage);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBufferSubData(GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, const void* data)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, BufferSubData)(target, offset, size, data);
-}
-
-static GLenum QOPENGLF_APIENTRY qopenglfResolveCheckFramebufferStatus(GLenum target)
-{
-    RESOLVE_FUNC(GLenum, ResolveOES | ResolveEXT, CheckFramebufferStatus)(target);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveCompileShader(GLuint shader)
-{
-    RESOLVE_FUNC_VOID(0, CompileShader)(shader);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, CompressedTexImage2D)(target, level, internalformat, width, height, border, imageSize, data);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, CompressedTexSubImage2D)(target, level, xoffset, yoffset, width, height, format, imageSize, data);
-}
-
-static GLuint QOPENGLF_APIENTRY qopenglfResolveCreateProgram()
-{
-    RESOLVE_FUNC(GLuint, 0, CreateProgram)();
-}
-
-static GLuint QOPENGLF_APIENTRY qopenglfResolveCreateShader(GLenum type)
-{
-    RESOLVE_FUNC(GLuint, 0, CreateShader)(type);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDeleteBuffers(GLsizei n, const GLuint* buffers)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, DeleteBuffers)(n, buffers);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDeleteFramebuffers(GLsizei n, const GLuint* framebuffers)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, DeleteFramebuffers)(n, framebuffers);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDeleteProgram(GLuint program)
-{
-    RESOLVE_FUNC_VOID(0, DeleteProgram)(program);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDeleteRenderbuffers(GLsizei n, const GLuint* renderbuffers)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, DeleteRenderbuffers)(n, renderbuffers);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDeleteShader(GLuint shader)
-{
-    RESOLVE_FUNC_VOID(0, DeleteShader)(shader);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDetachShader(GLuint program, GLuint shader)
-{
-    RESOLVE_FUNC_VOID(0, DetachShader)(program, shader);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDisableVertexAttribArray(GLuint index)
-{
-    RESOLVE_FUNC_VOID(0, DisableVertexAttribArray)(index);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveEnableVertexAttribArray(GLuint index)
-{
-    RESOLVE_FUNC_VOID(0, EnableVertexAttribArray)(index);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, FramebufferRenderbuffer)(target, attachment, renderbuffertarget, renderbuffer);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, FramebufferTexture2D)(target, attachment, textarget, texture, level);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGenBuffers(GLsizei n, GLuint* buffers)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, GenBuffers)(n, buffers);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGenerateMipmap(GLenum target)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, GenerateMipmap)(target);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGenFramebuffers(GLsizei n, GLuint* framebuffers)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, GenFramebuffers)(n, framebuffers);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGenRenderbuffers(GLsizei n, GLuint* renderbuffers)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, GenRenderbuffers)(n, renderbuffers);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetActiveAttrib(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
-{
-    RESOLVE_FUNC_VOID(0, GetActiveAttrib)(program, index, bufsize, length, size, type, name);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetActiveUniform(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)
-{
-    RESOLVE_FUNC_VOID(0, GetActiveUniform)(program, index, bufsize, length, size, type, name);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetAttachedShaders(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)
-{
-    RESOLVE_FUNC_VOID(0, GetAttachedShaders)(program, maxcount, count, shaders);
-}
-
-static GLint QOPENGLF_APIENTRY qopenglfResolveGetAttribLocation(GLuint program, const char* name)
-{
-    RESOLVE_FUNC(GLint, 0, GetAttribLocation)(program, name);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetBufferParameteriv(GLenum target, GLenum pname, GLint* params)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, GetBufferParameteriv)(target, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint* params)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, GetFramebufferAttachmentParameteriv)(target, attachment, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetProgramiv(GLuint program, GLenum pname, GLint* params)
-{
-    RESOLVE_FUNC_VOID(0, GetProgramiv)(program, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)
-{
-    RESOLVE_FUNC_VOID(0, GetProgramInfoLog)(program, bufsize, length, infolog);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint* params)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, GetRenderbufferParameteriv)(target, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetShaderiv(GLuint shader, GLenum pname, GLint* params)
+// some fallback functions
+static void QOPENGLF_APIENTRY qopenglfSpecialClearDepthf(GLclampf depth)
 {
-    RESOLVE_FUNC_VOID(0, GetShaderiv)(shader, pname, params);
+    QOpenGLContext *context = QOpenGLContext::currentContext();
+    QOpenGLFunctionsPrivate *funcs = qt_gl_functions(context);
+    funcs->f.ClearDepth((GLdouble) depth);
 }
 
-static void QOPENGLF_APIENTRY qopenglfResolveGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)
+static void QOPENGLF_APIENTRY qopenglfSpecialDepthRangef(GLclampf zNear, GLclampf zFar)
 {
-    RESOLVE_FUNC_VOID(0, GetShaderInfoLog)(shader, bufsize, length, infolog);
+    QOpenGLContext *context = QOpenGLContext::currentContext();
+    QOpenGLFunctionsPrivate *funcs = qt_gl_functions(context);
+    funcs->f.DepthRange((GLdouble) zNear, (GLdouble) zFar);
 }
 
 static void QOPENGLF_APIENTRY qopenglfSpecialGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
@@ -2926,539 +2169,47 @@ static void QOPENGLF_APIENTRY qopenglfSpecialGetShaderPrecisionFormat(GLenum sha
     range[0] = range[1] = precision[0] = 0;
 }
 
-static void QOPENGLF_APIENTRY qopenglfResolveGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)
-{
-    RESOLVE_FUNC_SPECIAL_VOID(ResolveOES | ResolveEXT, GetShaderPrecisionFormat)(shadertype, precisiontype, range, precision);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei* length, char* source)
-{
-    RESOLVE_FUNC_VOID(0, GetShaderSource)(shader, bufsize, length, source);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetUniformfv(GLuint program, GLint location, GLfloat* params)
-{
-    RESOLVE_FUNC_VOID(0, GetUniformfv)(program, location, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetUniformiv(GLuint program, GLint location, GLint* params)
-{
-    RESOLVE_FUNC_VOID(0, GetUniformiv)(program, location, params);
-}
-
-static GLint QOPENGLF_APIENTRY qopenglfResolveGetUniformLocation(GLuint program, const char* name)
-{
-    RESOLVE_FUNC(GLint, 0, GetUniformLocation)(program, name);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetVertexAttribfv(GLuint index, GLenum pname, GLfloat* params)
-{
-    RESOLVE_FUNC_VOID(0, GetVertexAttribfv)(index, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetVertexAttribiv(GLuint index, GLenum pname, GLint* params)
-{
-    RESOLVE_FUNC_VOID(0, GetVertexAttribiv)(index, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetVertexAttribPointerv(GLuint index, GLenum pname, void** pointer)
-{
-    RESOLVE_FUNC_VOID(0, GetVertexAttribPointerv)(index, pname, pointer);
-}
-
-static GLboolean QOPENGLF_APIENTRY qopenglfResolveIsBuffer(GLuint buffer)
-{
-    RESOLVE_FUNC(GLboolean, ResolveOES | ResolveEXT, IsBuffer)(buffer);
-}
-
-static GLboolean QOPENGLF_APIENTRY qopenglfResolveIsFramebuffer(GLuint framebuffer)
-{
-    RESOLVE_FUNC(GLboolean, ResolveOES | ResolveEXT, IsFramebuffer)(framebuffer);
-}
-
 static GLboolean QOPENGLF_APIENTRY qopenglfSpecialIsProgram(GLuint program)
 {
     return program != 0;
 }
 
-static GLboolean QOPENGLF_APIENTRY qopenglfResolveIsProgram(GLuint program)
-{
-    RESOLVE_FUNC_SPECIAL(GLboolean, 0, IsProgram)(program);
-}
-
-static GLboolean QOPENGLF_APIENTRY qopenglfResolveIsRenderbuffer(GLuint renderbuffer)
-{
-    RESOLVE_FUNC(GLboolean, ResolveOES | ResolveEXT, IsRenderbuffer)(renderbuffer);
-}
-
 static GLboolean QOPENGLF_APIENTRY qopenglfSpecialIsShader(GLuint shader)
 {
     return shader != 0;
 }
 
-static GLboolean QOPENGLF_APIENTRY qopenglfResolveIsShader(GLuint shader)
-{
-    RESOLVE_FUNC_SPECIAL(GLboolean, 0, IsShader)(shader);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveLinkProgram(GLuint program)
-{
-    RESOLVE_FUNC_VOID(0, LinkProgram)(program);
-}
-
 static void QOPENGLF_APIENTRY qopenglfSpecialReleaseShaderCompiler()
 {
 }
 
-static void QOPENGLF_APIENTRY qopenglfResolveReleaseShaderCompiler()
-{
-    RESOLVE_FUNC_SPECIAL_VOID(0, ReleaseShaderCompiler)();
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, RenderbufferStorage)(target, internalformat, width, height);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveSampleCoverage(GLclampf value, GLboolean invert)
-{
-    RESOLVE_FUNC_VOID(ResolveOES | ResolveEXT, SampleCoverage)(value, invert);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveShaderBinary(GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length)
-{
-    RESOLVE_FUNC_VOID(0, ShaderBinary)(n, shaders, binaryformat, binary, length);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveShaderSource(GLuint shader, GLsizei count, const char** string, const GLint* length)
-{
-    RESOLVE_FUNC_VOID(0, ShaderSource)(shader, count, string, length);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
-{
-    RESOLVE_FUNC_VOID(ResolveEXT, StencilFuncSeparate)(face, func, ref, mask);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveStencilMaskSeparate(GLenum face, GLuint mask)
-{
-    RESOLVE_FUNC_VOID(ResolveEXT, StencilMaskSeparate)(face, mask);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, GLenum zpass)
-{
-    RESOLVE_FUNC_VOID(ResolveEXT, StencilOpSeparate)(face, fail, zfail, zpass);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform1f(GLint location, GLfloat x)
-{
-    RESOLVE_FUNC_VOID(0, Uniform1f)(location, x);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform1fv(GLint location, GLsizei count, const GLfloat* v)
-{
-    RESOLVE_FUNC_VOID(0, Uniform1fv)(location, count, v);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform1i(GLint location, GLint x)
-{
-    RESOLVE_FUNC_VOID(0, Uniform1i)(location, x);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform1iv(GLint location, GLsizei count, const GLint* v)
-{
-    RESOLVE_FUNC_VOID(0, Uniform1iv)(location, count, v);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform2f(GLint location, GLfloat x, GLfloat y)
-{
-    RESOLVE_FUNC_VOID(0, Uniform2f)(location, x, y);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform2fv(GLint location, GLsizei count, const GLfloat* v)
-{
-    RESOLVE_FUNC_VOID(0, Uniform2fv)(location, count, v);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform2i(GLint location, GLint x, GLint y)
-{
-    RESOLVE_FUNC_VOID(0, Uniform2i)(location, x, y);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform2iv(GLint location, GLsizei count, const GLint* v)
-{
-    RESOLVE_FUNC_VOID(0, Uniform2iv)(location, count, v);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform3f(GLint location, GLfloat x, GLfloat y, GLfloat z)
-{
-    RESOLVE_FUNC_VOID(0, Uniform3f)(location, x, y, z);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform3fv(GLint location, GLsizei count, const GLfloat* v)
-{
-    RESOLVE_FUNC_VOID(0, Uniform3fv)(location, count, v);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform3i(GLint location, GLint x, GLint y, GLint z)
-{
-    RESOLVE_FUNC_VOID(0, Uniform3i)(location, x, y, z);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform3iv(GLint location, GLsizei count, const GLint* v)
-{
-    RESOLVE_FUNC_VOID(0, Uniform3iv)(location, count, v);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    RESOLVE_FUNC_VOID(0, Uniform4f)(location, x, y, z, w);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform4fv(GLint location, GLsizei count, const GLfloat* v)
-{
-    RESOLVE_FUNC_VOID(0, Uniform4fv)(location, count, v);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform4i(GLint location, GLint x, GLint y, GLint z, GLint w)
-{
-    RESOLVE_FUNC_VOID(0, Uniform4i)(location, x, y, z, w);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform4iv(GLint location, GLsizei count, const GLint* v)
-{
-    RESOLVE_FUNC_VOID(0, Uniform4iv)(location, count, v);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
-{
-    RESOLVE_FUNC_VOID(0, UniformMatrix2fv)(location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
-{
-    RESOLVE_FUNC_VOID(0, UniformMatrix3fv)(location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)
-{
-    RESOLVE_FUNC_VOID(0, UniformMatrix4fv)(location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUseProgram(GLuint program)
-{
-    RESOLVE_FUNC_VOID(0, UseProgram)(program);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveValidateProgram(GLuint program)
-{
-    RESOLVE_FUNC_VOID(0, ValidateProgram)(program);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttrib1f(GLuint indx, GLfloat x)
-{
-    RESOLVE_FUNC_VOID(0, VertexAttrib1f)(indx, x);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttrib1fv(GLuint indx, const GLfloat* values)
-{
-    RESOLVE_FUNC_VOID(0, VertexAttrib1fv)(indx, values);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y)
-{
-    RESOLVE_FUNC_VOID(0, VertexAttrib2f)(indx, x, y);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttrib2fv(GLuint indx, const GLfloat* values)
-{
-    RESOLVE_FUNC_VOID(0, VertexAttrib2fv)(indx, values);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z)
-{
-    RESOLVE_FUNC_VOID(0, VertexAttrib3f)(indx, x, y, z);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttrib3fv(GLuint indx, const GLfloat* values)
-{
-    RESOLVE_FUNC_VOID(0, VertexAttrib3fv)(indx, values);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
-{
-    RESOLVE_FUNC_VOID(0, VertexAttrib4f)(indx, x, y, z, w);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttrib4fv(GLuint indx, const GLfloat* values)
-{
-    RESOLVE_FUNC_VOID(0, VertexAttrib4fv)(indx, values);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttribPointer(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)
-{
-    RESOLVE_FUNC_VOID(0, VertexAttribPointer)(indx, size, type, normalized, stride, ptr);
-}
-
 #endif // !QT_OPENGL_ES_2
 
-// Extensions not standard in any ES version
 
-static GLvoid *QOPENGLF_APIENTRY qopenglfResolveMapBuffer(GLenum target, GLenum access)
+QOpenGLFunctionsPrivate::QOpenGLFunctionsPrivate(QOpenGLContext *c)
 {
-    // It is possible that GL_OES_map_buffer is present, but then having to
-    // differentiate between glUnmapBufferOES and glUnmapBuffer causes extra
-    // headache. QOpenGLBuffer::map() will handle this automatically, while direct
-    // calls are better off with migrating to the standard glMapBufferRange.
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-    if (ctx->isOpenGLES() && ctx->format().majorVersion() >= 3) {
-        qWarning("QOpenGLFunctions: glMapBuffer is not available in OpenGL ES 3.0 and up. Use glMapBufferRange instead.");
-        return 0;
-    } else {
-        RESOLVE_FUNC(GLvoid *, ResolveOES, MapBuffer)(target, access);
-    }
-}
+    init(c);
 
-static void QOPENGLF_APIENTRY qopenglfResolveGetBufferSubData(GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, GLvoid *data)
-{
-    RESOLVE_FUNC_VOID(ResolveEXT, GetBufferSubData)
-        (target, offset, size, data);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDiscardFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
-{
-    RESOLVE_FUNC_VOID(ResolveEXT, DiscardFramebuffer)(target, numAttachments, attachments);
-}
-
-#if !defined(QT_OPENGL_ES_2) && !defined(QT_OPENGL_DYNAMIC)
-// Special translation functions for ES-specific calls on desktop GL
-
-static void QOPENGLF_APIENTRY qopenglfTranslateClearDepthf(GLclampf depth)
-{
-    ::glClearDepth(depth);
-}
-
-static void QOPENGLF_APIENTRY qopenglfTranslateDepthRangef(GLclampf zNear, GLclampf zFar)
-{
-    ::glDepthRange(zNear, zFar);
-}
-#endif // !ES && !DYNAMIC
-
-QOpenGLFunctionsPrivate::QOpenGLFunctionsPrivate(QOpenGLContext *)
-{
-    /* Assign a pointer to an above defined static function
-     * which on first call resolves the function from the current
-     * context, assigns it to the member variable and executes it
-     * (see Resolver template) */
 #ifndef QT_OPENGL_ES_2
-    // The GL1 functions may not be queriable via getProcAddress().
-    if (QGuiApplicationPrivate::platformIntegration()->hasCapability(QPlatformIntegration::AllGLFunctionsQueryable)) {
-        // The platform plugin supports resolving these.
-        BindTexture = qopenglfResolveBindTexture;
-        BlendFunc = qopenglfResolveBlendFunc;
-        Clear = qopenglfResolveClear;
-        ClearColor = qopenglfResolveClearColor;
-        ClearDepthf = qopenglfResolveClearDepthf;
-        ClearStencil = qopenglfResolveClearStencil;
-        ColorMask = qopenglfResolveColorMask;
-        CopyTexImage2D = qopenglfResolveCopyTexImage2D;
-        CopyTexSubImage2D = qopenglfResolveCopyTexSubImage2D;
-        CullFace = qopenglfResolveCullFace;
-        DeleteTextures = qopenglfResolveDeleteTextures;
-        DepthFunc = qopenglfResolveDepthFunc;
-        DepthMask = qopenglfResolveDepthMask;
-        DepthRangef = qopenglfResolveDepthRangef;
-        Disable = qopenglfResolveDisable;
-        DrawArrays = qopenglfResolveDrawArrays;
-        DrawElements = qopenglfResolveDrawElements;
-        Enable = qopenglfResolveEnable;
-        Finish = qopenglfResolveFinish;
-        Flush = qopenglfResolveFlush;
-        FrontFace = qopenglfResolveFrontFace;
-        GenTextures = qopenglfResolveGenTextures;
-        GetBooleanv = qopenglfResolveGetBooleanv;
-        GetError = qopenglfResolveGetError;
-        GetFloatv = qopenglfResolveGetFloatv;
-        GetIntegerv = qopenglfResolveGetIntegerv;
-        GetString = qopenglfResolveGetString;
-        GetTexParameterfv = qopenglfResolveGetTexParameterfv;
-        GetTexParameteriv = qopenglfResolveGetTexParameteriv;
-        Hint = qopenglfResolveHint;
-        IsEnabled = qopenglfResolveIsEnabled;
-        IsTexture = qopenglfResolveIsTexture;
-        LineWidth = qopenglfResolveLineWidth;
-        PixelStorei = qopenglfResolvePixelStorei;
-        PolygonOffset = qopenglfResolvePolygonOffset;
-        ReadPixels = qopenglfResolveReadPixels;
-        Scissor = qopenglfResolveScissor;
-        StencilFunc = qopenglfResolveStencilFunc;
-        StencilMask = qopenglfResolveStencilMask;
-        StencilOp = qopenglfResolveStencilOp;
-        TexImage2D = qopenglfResolveTexImage2D;
-        TexParameterf = qopenglfResolveTexParameterf;
-        TexParameterfv = qopenglfResolveTexParameterfv;
-        TexParameteri = qopenglfResolveTexParameteri;
-        TexParameteriv = qopenglfResolveTexParameteriv;
-        TexSubImage2D = qopenglfResolveTexSubImage2D;
-        Viewport = qopenglfResolveViewport;
-    } else {
-#ifndef QT_OPENGL_DYNAMIC
-        // Use the functions directly. This requires linking QtGui to an OpenGL implementation.
-        BindTexture = ::glBindTexture;
-        BlendFunc = ::glBlendFunc;
-        Clear = ::glClear;
-        ClearColor = ::glClearColor;
-        ClearDepthf = qopenglfTranslateClearDepthf;
-        ClearStencil = ::glClearStencil;
-        ColorMask = ::glColorMask;
-        CopyTexImage2D = ::glCopyTexImage2D;
-        CopyTexSubImage2D = ::glCopyTexSubImage2D;
-        CullFace = ::glCullFace;
-        DeleteTextures = ::glDeleteTextures;
-        DepthFunc = ::glDepthFunc;
-        DepthMask = ::glDepthMask;
-        DepthRangef = qopenglfTranslateDepthRangef;
-        Disable = ::glDisable;
-        DrawArrays = ::glDrawArrays;
-        DrawElements = ::glDrawElements;
-        Enable = ::glEnable;
-        Finish = ::glFinish;
-        Flush = ::glFlush;
-        FrontFace = ::glFrontFace;
-        GenTextures = ::glGenTextures;
-        GetBooleanv = ::glGetBooleanv;
-        GetError = ::glGetError;
-        GetFloatv = ::glGetFloatv;
-        GetIntegerv = ::glGetIntegerv;
-        GetString = ::glGetString;
-        GetTexParameterfv = ::glGetTexParameterfv;
-        GetTexParameteriv = ::glGetTexParameteriv;
-        Hint = ::glHint;
-        IsEnabled = ::glIsEnabled;
-        IsTexture = ::glIsTexture;
-        LineWidth = ::glLineWidth;
-        PixelStorei = ::glPixelStorei;
-        PolygonOffset = ::glPolygonOffset;
-        ReadPixels = ::glReadPixels;
-        Scissor = ::glScissor;
-        StencilFunc = ::glStencilFunc;
-        StencilMask = ::glStencilMask;
-        StencilOp = ::glStencilOp;
-#if defined(Q_OS_OSX) && MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_7
-        TexImage2D = reinterpret_cast<void (*)(GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid *)>(glTexImage2D);
-#else
-        TexImage2D = glTexImage2D;
+    // setup fallbacks in case some methods couldn't get resolved
+    if (!f.ClearDepthf)
+        f.ClearDepthf = qopenglfSpecialClearDepthf;
+    if (!f.DepthRangef)
+        f.DepthRangef = qopenglfSpecialDepthRangef;
+    if (!f.GetShaderPrecisionFormat)
+        f.GetShaderPrecisionFormat = qopenglfSpecialGetShaderPrecisionFormat;
+    if (!f.IsProgram)
+        f.IsProgram = qopenglfSpecialIsProgram;
+    if (!f.IsShader)
+        f.IsShader = qopenglfSpecialIsShader;
+    if (!f.ReleaseShaderCompiler)
+        f.ReleaseShaderCompiler = qopenglfSpecialReleaseShaderCompiler;
 #endif
-        TexParameterf = ::glTexParameterf;
-        TexParameterfv = ::glTexParameterfv;
-        TexParameteri = ::glTexParameteri;
-        TexParameteriv = ::glTexParameteriv;
-        TexSubImage2D = ::glTexSubImage2D;
-        Viewport = ::glViewport;
-#else // QT_OPENGL_DYNAMIC
-        // This should not happen.
-        qFatal("QOpenGLFunctions: Dynamic OpenGL builds do not support platforms with insufficient function resolving capabilities");
-#endif
-    }
-
-    ActiveTexture = qopenglfResolveActiveTexture;
-    AttachShader = qopenglfResolveAttachShader;
-    BindAttribLocation = qopenglfResolveBindAttribLocation;
-    BindBuffer = qopenglfResolveBindBuffer;
-    BindFramebuffer = qopenglfResolveBindFramebuffer;
-    BindRenderbuffer = qopenglfResolveBindRenderbuffer;
-    BlendColor = qopenglfResolveBlendColor;
-    BlendEquation = qopenglfResolveBlendEquation;
-    BlendEquationSeparate = qopenglfResolveBlendEquationSeparate;
-    BlendFuncSeparate = qopenglfResolveBlendFuncSeparate;
-    BufferData = qopenglfResolveBufferData;
-    BufferSubData = qopenglfResolveBufferSubData;
-    CheckFramebufferStatus = qopenglfResolveCheckFramebufferStatus;
-    CompileShader = qopenglfResolveCompileShader;
-    CompressedTexImage2D = qopenglfResolveCompressedTexImage2D;
-    CompressedTexSubImage2D = qopenglfResolveCompressedTexSubImage2D;
-    CreateProgram = qopenglfResolveCreateProgram;
-    CreateShader = qopenglfResolveCreateShader;
-    DeleteBuffers = qopenglfResolveDeleteBuffers;
-    DeleteFramebuffers = qopenglfResolveDeleteFramebuffers;
-    DeleteProgram = qopenglfResolveDeleteProgram;
-    DeleteRenderbuffers = qopenglfResolveDeleteRenderbuffers;
-    DeleteShader = qopenglfResolveDeleteShader;
-    DetachShader = qopenglfResolveDetachShader;
-    DisableVertexAttribArray = qopenglfResolveDisableVertexAttribArray;
-    EnableVertexAttribArray = qopenglfResolveEnableVertexAttribArray;
-    FramebufferRenderbuffer = qopenglfResolveFramebufferRenderbuffer;
-    FramebufferTexture2D = qopenglfResolveFramebufferTexture2D;
-    GenBuffers = qopenglfResolveGenBuffers;
-    GenerateMipmap = qopenglfResolveGenerateMipmap;
-    GenFramebuffers = qopenglfResolveGenFramebuffers;
-    GenRenderbuffers = qopenglfResolveGenRenderbuffers;
-    GetActiveAttrib = qopenglfResolveGetActiveAttrib;
-    GetActiveUniform = qopenglfResolveGetActiveUniform;
-    GetAttachedShaders = qopenglfResolveGetAttachedShaders;
-    GetAttribLocation = qopenglfResolveGetAttribLocation;
-    GetBufferParameteriv = qopenglfResolveGetBufferParameteriv;
-    GetFramebufferAttachmentParameteriv = qopenglfResolveGetFramebufferAttachmentParameteriv;
-    GetProgramiv = qopenglfResolveGetProgramiv;
-    GetProgramInfoLog = qopenglfResolveGetProgramInfoLog;
-    GetRenderbufferParameteriv = qopenglfResolveGetRenderbufferParameteriv;
-    GetShaderiv = qopenglfResolveGetShaderiv;
-    GetShaderInfoLog = qopenglfResolveGetShaderInfoLog;
-    GetShaderPrecisionFormat = qopenglfResolveGetShaderPrecisionFormat;
-    GetShaderSource = qopenglfResolveGetShaderSource;
-    GetUniformfv = qopenglfResolveGetUniformfv;
-    GetUniformiv = qopenglfResolveGetUniformiv;
-    GetUniformLocation = qopenglfResolveGetUniformLocation;
-    GetVertexAttribfv = qopenglfResolveGetVertexAttribfv;
-    GetVertexAttribiv = qopenglfResolveGetVertexAttribiv;
-    GetVertexAttribPointerv = qopenglfResolveGetVertexAttribPointerv;
-    IsBuffer = qopenglfResolveIsBuffer;
-    IsFramebuffer = qopenglfResolveIsFramebuffer;
-    IsProgram = qopenglfResolveIsProgram;
-    IsRenderbuffer = qopenglfResolveIsRenderbuffer;
-    IsShader = qopenglfResolveIsShader;
-    LinkProgram = qopenglfResolveLinkProgram;
-    ReleaseShaderCompiler = qopenglfResolveReleaseShaderCompiler;
-    RenderbufferStorage = qopenglfResolveRenderbufferStorage;
-    SampleCoverage = qopenglfResolveSampleCoverage;
-    ShaderBinary = qopenglfResolveShaderBinary;
-    ShaderSource = qopenglfResolveShaderSource;
-    StencilFuncSeparate = qopenglfResolveStencilFuncSeparate;
-    StencilMaskSeparate = qopenglfResolveStencilMaskSeparate;
-    StencilOpSeparate = qopenglfResolveStencilOpSeparate;
-    Uniform1f = qopenglfResolveUniform1f;
-    Uniform1fv = qopenglfResolveUniform1fv;
-    Uniform1i = qopenglfResolveUniform1i;
-    Uniform1iv = qopenglfResolveUniform1iv;
-    Uniform2f = qopenglfResolveUniform2f;
-    Uniform2fv = qopenglfResolveUniform2fv;
-    Uniform2i = qopenglfResolveUniform2i;
-    Uniform2iv = qopenglfResolveUniform2iv;
-    Uniform3f = qopenglfResolveUniform3f;
-    Uniform3fv = qopenglfResolveUniform3fv;
-    Uniform3i = qopenglfResolveUniform3i;
-    Uniform3iv = qopenglfResolveUniform3iv;
-    Uniform4f = qopenglfResolveUniform4f;
-    Uniform4fv = qopenglfResolveUniform4fv;
-    Uniform4i = qopenglfResolveUniform4i;
-    Uniform4iv = qopenglfResolveUniform4iv;
-    UniformMatrix2fv = qopenglfResolveUniformMatrix2fv;
-    UniformMatrix3fv = qopenglfResolveUniformMatrix3fv;
-    UniformMatrix4fv = qopenglfResolveUniformMatrix4fv;
-    UseProgram = qopenglfResolveUseProgram;
-    ValidateProgram = qopenglfResolveValidateProgram;
-    VertexAttrib1f = qopenglfResolveVertexAttrib1f;
-    VertexAttrib1fv = qopenglfResolveVertexAttrib1fv;
-    VertexAttrib2f = qopenglfResolveVertexAttrib2f;
-    VertexAttrib2fv = qopenglfResolveVertexAttrib2fv;
-    VertexAttrib3f = qopenglfResolveVertexAttrib3f;
-    VertexAttrib3fv = qopenglfResolveVertexAttrib3fv;
-    VertexAttrib4f = qopenglfResolveVertexAttrib4f;
-    VertexAttrib4fv = qopenglfResolveVertexAttrib4fv;
-    VertexAttribPointer = qopenglfResolveVertexAttribPointer;
-#endif // !QT_OPENGL_ES_2
 }
 
+
+QT_OPENGL_IMPLEMENT(QOpenGLFunctionsPrivate, QT_OPENGL_FUNCTIONS)
+
 /*!
     \class QOpenGLExtraFunctions
     \brief The QOpenGLExtraFunctions class provides cross-platform access to the OpenGL ES 3.0 and 3.1 API.
@@ -5721,1659 +4472,6 @@ QOpenGLFunctionsPrivate::QOpenGLFunctionsPrivate(QOpenGLContext *)
     \internal
 */
 
-// Functions part of the OpenGL ES 3.0+ standard need special handling. These, just like
-// the 2.0 functions, are not guaranteed to be resolvable via eglGetProcAddress or
-// similar. (we cannot count on EGL_KHR_(client_)get_all_proc_addresses being available)
-
-// Calling them directly is, unlike the 2.0 functions, not feasible because one may build
-// the binaries on a GLES3-capable system and then deploy on a GLES2-only system that does
-// not have these symbols, and vice versa. Until ES3 becomes universally available, they
-// have to be dlsym'ed.
-
-Q_GLOBAL_STATIC(QOpenGLES3Helper, qgles3Helper)
-
-bool QOpenGLES3Helper::init()
-{
-#ifdef QT_NO_LIBRARY
-    return false;
-#elif !defined(Q_OS_IOS)
-# ifdef Q_OS_WIN
-#  ifndef QT_DEBUG
-    m_gl.setFileName(QStringLiteral("libGLESv2"));
-#  else
-    m_gl.setFileName(QStringLiteral("libGLESv2d"));
-#  endif
-# else
-#  ifdef Q_OS_ANDROID
-    m_gl.setFileName(QStringLiteral("GLESv2"));
-#  else
-    m_gl.setFileNameAndVersion(QStringLiteral("GLESv2"), 2);
-#  endif
-# endif // Q_OS_WIN
-    return m_gl.load();
-#else
-    return true;
-#endif // Q_OS_IOS
-}
-
-QFunctionPointer QOpenGLES3Helper::resolve(const char *name)
-{
-#ifdef Q_OS_IOS
-    return QFunctionPointer(dlsym(RTLD_DEFAULT, name));
-#elif !defined(QT_NO_LIBRARY)
-    return m_gl.resolve(name);
-#else
-    Q_UNUSED(name);
-    return 0;
-#endif
-}
-
-QOpenGLES3Helper::QOpenGLES3Helper()
-{
-    m_supportedVersion = qMakePair(2, 0);
-
-    if (Q_UNLIKELY(!init())) {
-        qFatal("Failed to load libGLESv2");
-    } else {
-        const QPair<int, int> contextVersion = QOpenGLContext::currentContext()->format().version();
-
-        qCDebug(lcGLES3, "Resolving OpenGL ES 3.0 entry points");
-
-        BeginQuery = (void (QOPENGLF_APIENTRYP) (GLenum, GLuint)) resolve("glBeginQuery");
-        BeginTransformFeedback = (void (QOPENGLF_APIENTRYP) (GLenum)) resolve("glBeginTransformFeedback");
-        BindBufferBase = (void (QOPENGLF_APIENTRYP) (GLenum, GLuint, GLuint)) resolve("glBindBufferBase");
-        BindBufferRange = (void (QOPENGLF_APIENTRYP) (GLenum, GLuint, GLuint, GLintptr, GLsizeiptr)) resolve("glBindBufferRange");
-        BindSampler = (void (QOPENGLF_APIENTRYP) (GLuint, GLuint)) resolve("glBindSampler");
-        BindTransformFeedback = (void (QOPENGLF_APIENTRYP) (GLenum, GLuint)) resolve("glBindTransformFeedback");
-        BindVertexArray = (void (QOPENGLF_APIENTRYP) (GLuint)) resolve("glBindVertexArray");
-        BlitFramebuffer = (void (QOPENGLF_APIENTRYP) (GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLint, GLbitfield, GLenum)) resolve("glBlitFramebuffer");
-        ClearBufferfi = (void (QOPENGLF_APIENTRYP) (GLenum, GLint, GLfloat, GLint)) resolve("glClearBufferfi");
-        ClearBufferfv = (void (QOPENGLF_APIENTRYP) (GLenum, GLint, const GLfloat *)) resolve("glClearBufferfv");
-        ClearBufferiv = (void (QOPENGLF_APIENTRYP) (GLenum, GLint, const GLint *)) resolve("glClearBufferiv");
-        ClearBufferuiv = (void (QOPENGLF_APIENTRYP) (GLenum, GLint, const GLuint *)) resolve("glClearBufferuiv");
-        ClientWaitSync = (GLenum (QOPENGLF_APIENTRYP) (GLsync, GLbitfield, GLuint64)) resolve("glClientWaitSync");
-        CompressedTexImage3D = (void (QOPENGLF_APIENTRYP) (GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const void *)) resolve("glCompressedTexImage3D");
-        CompressedTexSubImage3D = (void (QOPENGLF_APIENTRYP) (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const void *)) resolve("glCompressedTexSubImage3D");
-        CopyBufferSubData = (void (QOPENGLF_APIENTRYP) (GLenum, GLenum, GLintptr, GLintptr, GLsizeiptr)) resolve("glCopyBufferSubData");
-        CopyTexSubImage3D = (void (QOPENGLF_APIENTRYP) (GLenum, GLint, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei)) resolve("glCopyTexSubImage3D");
-        DeleteQueries = (void (QOPENGLF_APIENTRYP) (GLsizei, const GLuint *)) resolve("glDeleteQueries");
-        DeleteSamplers = (void (QOPENGLF_APIENTRYP) (GLsizei, const GLuint *)) resolve("glDeleteSamplers");
-        DeleteSync = (void (QOPENGLF_APIENTRYP) (GLsync)) resolve("glDeleteSync");
-        DeleteTransformFeedbacks = (void (QOPENGLF_APIENTRYP) (GLsizei, const GLuint *)) resolve("glDeleteTransformFeedbacks");
-        DeleteVertexArrays = (void (QOPENGLF_APIENTRYP) (GLsizei, const GLuint *)) resolve("glDeleteVertexArrays");
-        DrawArraysInstanced = (void (QOPENGLF_APIENTRYP) (GLenum, GLint, GLsizei, GLsizei)) resolve("glDrawArraysInstanced");
-        DrawBuffers = (void (QOPENGLF_APIENTRYP) (GLsizei, const GLenum *)) resolve("glDrawBuffers");
-        DrawElementsInstanced = (void (QOPENGLF_APIENTRYP) (GLenum, GLsizei, GLenum, const void *, GLsizei)) resolve("glDrawElementsInstanced");
-        DrawRangeElements = (void (QOPENGLF_APIENTRYP) (GLenum, GLuint, GLuint, GLsizei, GLenum, const void *)) resolve("glDrawRangeElements");
-        EndQuery = (void (QOPENGLF_APIENTRYP) (GLenum)) resolve("glEndQuery");
-        EndTransformFeedback = (void (QOPENGLF_APIENTRYP) ()) resolve("glEndTransformFeedback");
-        FenceSync = (GLsync (QOPENGLF_APIENTRYP) (GLenum, GLbitfield)) resolve("glFenceSync");
-        FlushMappedBufferRange = (void (QOPENGLF_APIENTRYP) (GLenum, GLintptr, GLsizeiptr)) resolve("glFlushMappedBufferRange");
-        FramebufferTextureLayer = (void (QOPENGLF_APIENTRYP) (GLenum, GLenum, GLuint, GLint, GLint)) resolve("glFramebufferTextureLayer");
-        GenQueries = (void (QOPENGLF_APIENTRYP) (GLsizei, GLuint*)) resolve("glGenQueries");
-        GenSamplers = (void (QOPENGLF_APIENTRYP) (GLsizei, GLuint*)) resolve("glGenSamplers");
-        GenTransformFeedbacks = (void (QOPENGLF_APIENTRYP) (GLsizei, GLuint*)) resolve("glGenTransformFeedbacks");
-        GenVertexArrays = (void (QOPENGLF_APIENTRYP) (GLsizei, GLuint*)) resolve("glGenVertexArrays");
-        GetActiveUniformBlockName = (void (QOPENGLF_APIENTRYP) (GLuint, GLuint, GLsizei, GLsizei*, GLchar*)) resolve("glGetActiveUniformBlockName");
-        GetActiveUniformBlockiv = (void (QOPENGLF_APIENTRYP) (GLuint, GLuint, GLenum, GLint*)) resolve("glGetActiveUniformBlockiv");
-        GetActiveUniformsiv = (void (QOPENGLF_APIENTRYP) (GLuint, GLsizei, const GLuint *, GLenum, GLint*)) resolve("glGetActiveUniformsiv");
-        GetBufferParameteri64v = (void (QOPENGLF_APIENTRYP) (GLenum, GLenum, GLint64*)) resolve("glGetBufferParameteri64v");
-        GetBufferPointerv = (void (QOPENGLF_APIENTRYP) (GLenum, GLenum, void **)) resolve("glGetBufferPointerv");
-        GetFragDataLocation = (GLint (QOPENGLF_APIENTRYP) (GLuint, const GLchar *)) resolve("glGetFragDataLocation");
-        GetInteger64i_v = (void (QOPENGLF_APIENTRYP) (GLenum, GLuint, GLint64*)) resolve("glGetInteger64i_v");
-        GetInteger64v = (void (QOPENGLF_APIENTRYP) (GLenum, GLint64*)) resolve("glGetInteger64v");
-        GetIntegeri_v = (void (QOPENGLF_APIENTRYP) (GLenum, GLuint, GLint*)) resolve("glGetIntegeri_v");
-        GetInternalformativ = (void (QOPENGLF_APIENTRYP) (GLenum, GLenum, GLenum, GLsizei, GLint*)) resolve("glGetInternalformativ");
-        GetProgramBinary = (void (QOPENGLF_APIENTRYP) (GLuint, GLsizei, GLsizei*, GLenum*, void *)) resolve("glGetProgramBinary");
-        GetQueryObjectuiv = (void (QOPENGLF_APIENTRYP) (GLuint, GLenum, GLuint*)) resolve("glGetQueryObjectuiv");
-        GetQueryiv = (void (QOPENGLF_APIENTRYP) (GLenum, GLenum, GLint*)) resolve("glGetQueryiv");
-        GetSamplerParameterfv = (void (QOPENGLF_APIENTRYP) (GLuint, GLenum, GLfloat*)) resolve("glGetSamplerParameterfv");
-        GetSamplerParameteriv = (void (QOPENGLF_APIENTRYP) (GLuint, GLenum, GLint*)) resolve("glGetSamplerParameteriv");
-        GetStringi = (const GLubyte * (QOPENGLF_APIENTRYP) (GLenum, GLuint)) resolve("glGetStringi");
-        GetSynciv = (void (QOPENGLF_APIENTRYP) (GLsync, GLenum, GLsizei, GLsizei*, GLint*)) resolve("glGetSynciv");
-        GetTransformFeedbackVarying = (void (QOPENGLF_APIENTRYP) (GLuint, GLuint, GLsizei, GLsizei*, GLsizei*, GLenum*, GLchar*)) resolve("glGetTransformFeedbackVarying");
-        GetUniformBlockIndex = (GLuint (QOPENGLF_APIENTRYP) (GLuint, const GLchar *)) resolve("glGetUniformBlockIndex");
-        GetUniformIndices = (void (QOPENGLF_APIENTRYP) (GLuint, GLsizei, const GLchar *const*, GLuint*)) resolve("glGetUniformIndices");
-        GetUniformuiv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLuint*)) resolve("glGetUniformuiv");
-        GetVertexAttribIiv = (void (QOPENGLF_APIENTRYP) (GLuint, GLenum, GLint*)) resolve("glGetVertexAttribIiv");
-        GetVertexAttribIuiv = (void (QOPENGLF_APIENTRYP) (GLuint, GLenum, GLuint*)) resolve("glGetVertexAttribIuiv");
-        InvalidateFramebuffer = (void (QOPENGLF_APIENTRYP) (GLenum, GLsizei, const GLenum *)) resolve("glInvalidateFramebuffer");
-        InvalidateSubFramebuffer = (void (QOPENGLF_APIENTRYP) (GLenum, GLsizei, const GLenum *, GLint, GLint, GLsizei, GLsizei)) resolve("glInvalidateSubFramebuffer");
-        IsQuery = (GLboolean (QOPENGLF_APIENTRYP) (GLuint)) resolve("glIsQuery");
-        IsSampler = (GLboolean (QOPENGLF_APIENTRYP) (GLuint)) resolve("glIsSampler");
-        IsSync = (GLboolean (QOPENGLF_APIENTRYP) (GLsync)) resolve("glIsSync");
-        IsTransformFeedback = (GLboolean (QOPENGLF_APIENTRYP) (GLuint)) resolve("glIsTransformFeedback");
-        IsVertexArray = (GLboolean (QOPENGLF_APIENTRYP) (GLuint)) resolve("glIsVertexArray");
-        MapBufferRange = (void * (QOPENGLF_APIENTRYP) (GLenum, GLintptr, GLsizeiptr, GLbitfield)) resolve("glMapBufferRange");
-        PauseTransformFeedback = (void (QOPENGLF_APIENTRYP) ()) resolve("glPauseTransformFeedback");
-        ProgramBinary = (void (QOPENGLF_APIENTRYP) (GLuint, GLenum, const void *, GLsizei)) resolve("glProgramBinary");
-        ProgramParameteri = (void (QOPENGLF_APIENTRYP) (GLuint, GLenum, GLint)) resolve("glProgramParameteri");
-        ReadBuffer = (void (QOPENGLF_APIENTRYP) (GLenum)) resolve("glReadBuffer");
-        RenderbufferStorageMultisample = (void (QOPENGLF_APIENTRYP) (GLenum, GLsizei, GLenum, GLsizei, GLsizei)) resolve("glRenderbufferStorageMultisample");
-        ResumeTransformFeedback = (void (QOPENGLF_APIENTRYP) ()) resolve("glResumeTransformFeedback");
-        SamplerParameterf = (void (QOPENGLF_APIENTRYP) (GLuint, GLenum, GLfloat)) resolve("glSamplerParameterf");
-        SamplerParameterfv = (void (QOPENGLF_APIENTRYP) (GLuint, GLenum, const GLfloat *)) resolve("glSamplerParameterfv");
-        SamplerParameteri = (void (QOPENGLF_APIENTRYP) (GLuint, GLenum, GLint)) resolve("glSamplerParameteri");
-        SamplerParameteriv = (void (QOPENGLF_APIENTRYP) (GLuint, GLenum, const GLint *)) resolve("glSamplerParameteriv");
-        TexImage3D = (void (QOPENGLF_APIENTRYP) (GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const void *)) resolve("glTexImage3D");
-        TexStorage2D = (void (QOPENGLF_APIENTRYP) (GLenum, GLsizei, GLenum, GLsizei, GLsizei)) resolve("glTexStorage2D");
-        TexStorage3D = (void (QOPENGLF_APIENTRYP) (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLsizei)) resolve("glTexStorage3D");
-        TexSubImage3D = (void (QOPENGLF_APIENTRYP) (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const void *)) resolve("glTexSubImage3D");
-        TransformFeedbackVaryings = (void (QOPENGLF_APIENTRYP) (GLuint, GLsizei, const GLchar *const*, GLenum)) resolve("glTransformFeedbackVaryings");
-        Uniform1ui = (void (QOPENGLF_APIENTRYP) (GLint, GLuint)) resolve("glUniform1ui");
-        Uniform1uiv = (void (QOPENGLF_APIENTRYP) (GLint, GLsizei, const GLuint *)) resolve("glUniform1uiv");
-        Uniform2ui = (void (QOPENGLF_APIENTRYP) (GLint, GLuint, GLuint)) resolve("glUniform2ui");
-        Uniform2uiv = (void (QOPENGLF_APIENTRYP) (GLint, GLsizei, const GLuint *)) resolve("glUniform2uiv");
-        Uniform3ui = (void (QOPENGLF_APIENTRYP) (GLint, GLuint, GLuint, GLuint)) resolve("glUniform3ui");
-        Uniform3uiv = (void (QOPENGLF_APIENTRYP) (GLint, GLsizei, const GLuint *)) resolve("glUniform3uiv");
-        Uniform4ui = (void (QOPENGLF_APIENTRYP) (GLint, GLuint, GLuint, GLuint, GLuint)) resolve("glUniform4ui");
-        Uniform4uiv = (void (QOPENGLF_APIENTRYP) (GLint, GLsizei, const GLuint *)) resolve("glUniform4uiv");
-        UniformBlockBinding = (void (QOPENGLF_APIENTRYP) (GLuint, GLuint, GLuint)) resolve("glUniformBlockBinding");
-        UniformMatrix2x3fv = (void (QOPENGLF_APIENTRYP) (GLint, GLsizei, GLboolean, const GLfloat *)) resolve("glUniformMatrix2x3fv");
-        UniformMatrix2x4fv = (void (QOPENGLF_APIENTRYP) (GLint, GLsizei, GLboolean, const GLfloat *)) resolve("glUniformMatrix2x4fv");
-        UniformMatrix3x2fv = (void (QOPENGLF_APIENTRYP) (GLint, GLsizei, GLboolean, const GLfloat *)) resolve("glUniformMatrix3x2fv");
-        UniformMatrix3x4fv = (void (QOPENGLF_APIENTRYP) (GLint, GLsizei, GLboolean, const GLfloat *)) resolve("glUniformMatrix3x4fv");
-        UniformMatrix4x2fv = (void (QOPENGLF_APIENTRYP) (GLint, GLsizei, GLboolean, const GLfloat *)) resolve("glUniformMatrix4x2fv");
-        UniformMatrix4x3fv = (void (QOPENGLF_APIENTRYP) (GLint, GLsizei, GLboolean, const GLfloat *)) resolve("glUniformMatrix4x3fv");
-        UnmapBuffer = (GLboolean (QOPENGLF_APIENTRYP) (GLenum)) resolve("glUnmapBuffer");
-        VertexAttribDivisor = (void (QOPENGLF_APIENTRYP) (GLuint, GLuint)) resolve("glVertexAttribDivisor");
-        VertexAttribI4i = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLint, GLint, GLint)) resolve("glVertexAttribI4i");
-        VertexAttribI4iv = (void (QOPENGLF_APIENTRYP) (GLuint, const GLint *)) resolve("glVertexAttribI4iv");
-        VertexAttribI4ui = (void (QOPENGLF_APIENTRYP) (GLuint, GLuint, GLuint, GLuint, GLuint)) resolve("glVertexAttribI4ui");
-        VertexAttribI4uiv = (void (QOPENGLF_APIENTRYP) (GLuint, const GLuint *)) resolve("glVertexAttribI4uiv");
-        VertexAttribIPointer = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLenum, GLsizei, const void *)) resolve("glVertexAttribIPointer");
-        WaitSync = (void (QOPENGLF_APIENTRYP) (GLsync, GLbitfield, GLuint64)) resolve("glWaitSync");
-
-        if (!BeginQuery || !BlitFramebuffer || !GenTransformFeedbacks || !GenVertexArrays || !MapBufferRange
-            || !RenderbufferStorageMultisample || !TexStorage2D || !WaitSync) {
-            qWarning("OpenGL ES 3.0 entry points not found. This is odd because the driver returned a context of version %d.%d",
-                     contextVersion.first, contextVersion.second);
-            return;
-        }
-        m_supportedVersion = qMakePair(3, 0);
-
-        if (contextVersion >= qMakePair(3, 1)) {
-            qCDebug(lcGLES3, "Resolving OpenGL ES 3.1 entry points");
-
-            ActiveShaderProgram = (void (QOPENGLF_APIENTRYP) (GLuint, GLuint)) resolve("glActiveShaderProgram");
-            BindImageTexture = (void (QOPENGLF_APIENTRYP) (GLuint, GLuint, GLint, GLboolean, GLint, GLenum, GLenum)) resolve("glBindImageTexture");
-            BindProgramPipeline = (void (QOPENGLF_APIENTRYP) (GLuint)) resolve("glBindProgramPipeline");
-            BindVertexBuffer = (void (QOPENGLF_APIENTRYP) (GLuint, GLuint, GLintptr, GLsizei)) resolve("glBindVertexBuffer");
-            CreateShaderProgramv = (GLuint (QOPENGLF_APIENTRYP) (GLenum, GLsizei, const GLchar *const*)) resolve("glCreateShaderProgramv");
-            DeleteProgramPipelines = (void (QOPENGLF_APIENTRYP) (GLsizei, const GLuint *)) resolve("glDeleteProgramPipelines");
-            DispatchCompute = (void (QOPENGLF_APIENTRYP) (GLuint, GLuint, GLuint)) resolve("glDispatchCompute");
-            DispatchComputeIndirect = (void (QOPENGLF_APIENTRYP) (GLintptr)) resolve("glDispatchComputeIndirect");
-            DrawArraysIndirect = (void (QOPENGLF_APIENTRYP) (GLenum, const void *)) resolve("glDrawArraysIndirect");
-            DrawElementsIndirect = (void (QOPENGLF_APIENTRYP) (GLenum, GLenum, const void *)) resolve("glDrawElementsIndirect");
-            FramebufferParameteri = (void (QOPENGLF_APIENTRYP) (GLenum, GLenum, GLint)) resolve("glFramebufferParameteri");
-            GenProgramPipelines = (void (QOPENGLF_APIENTRYP) (GLsizei, GLuint*)) resolve("glGenProgramPipelines");
-            GetBooleani_v = (void (QOPENGLF_APIENTRYP) (GLenum, GLuint, GLboolean*)) resolve("glGetBooleani_v");
-            GetFramebufferParameteriv = (void (QOPENGLF_APIENTRYP) (GLenum, GLenum, GLint*)) resolve("glGetFramebufferParameteriv");
-            GetMultisamplefv = (void (QOPENGLF_APIENTRYP) (GLenum, GLuint, GLfloat*)) resolve("glGetMultisamplefv");
-            GetProgramInterfaceiv = (void (QOPENGLF_APIENTRYP) (GLuint, GLenum, GLenum, GLint*)) resolve("glGetProgramInterfaceiv");
-            GetProgramPipelineInfoLog = (void (QOPENGLF_APIENTRYP) (GLuint, GLsizei, GLsizei*, GLchar*)) resolve("glGetProgramPipelineInfoLog");
-            GetProgramPipelineiv = (void (QOPENGLF_APIENTRYP) (GLuint, GLenum, GLint*)) resolve("glGetProgramPipelineiv");
-            GetProgramResourceIndex = (GLuint (QOPENGLF_APIENTRYP) (GLuint, GLenum, const GLchar *)) resolve("glGetProgramResourceIndex");
-            GetProgramResourceLocation = (GLint (QOPENGLF_APIENTRYP) (GLuint, GLenum, const GLchar *)) resolve("glGetProgramResourceLocation");
-            GetProgramResourceName = (void (QOPENGLF_APIENTRYP) (GLuint, GLenum, GLuint, GLsizei, GLsizei*, GLchar*)) resolve("glGetProgramResourceName");
-            GetProgramResourceiv = (void (QOPENGLF_APIENTRYP) (GLuint, GLenum, GLuint, GLsizei, const GLenum *, GLsizei, GLsizei*, GLint*)) resolve("glGetProgramResourceiv");
-            GetTexLevelParameterfv = (void (QOPENGLF_APIENTRYP) (GLenum, GLint, GLenum, GLfloat*)) resolve("glGetTexLevelParameterfv");
-            GetTexLevelParameteriv = (void (QOPENGLF_APIENTRYP) (GLenum, GLint, GLenum, GLint*)) resolve("glGetTexLevelParameteriv");
-            IsProgramPipeline = (GLboolean (QOPENGLF_APIENTRYP) (GLuint)) resolve("glIsProgramPipeline");
-            MemoryBarrierFunc = (void (QOPENGLF_APIENTRYP) (GLbitfield)) resolve("glMemoryBarrier");
-            MemoryBarrierByRegion = (void (QOPENGLF_APIENTRYP) (GLbitfield)) resolve("glMemoryBarrierByRegion");
-            ProgramUniform1f = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLfloat)) resolve("glProgramUniform1f");
-            ProgramUniform1fv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, const GLfloat *)) resolve("glProgramUniform1fv");
-            ProgramUniform1i = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLint)) resolve("glProgramUniform1i");
-            ProgramUniform1iv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, const GLint *)) resolve("glProgramUniform1iv");
-            ProgramUniform1ui = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLuint)) resolve("glProgramUniform1ui");
-            ProgramUniform1uiv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, const GLuint *)) resolve("glProgramUniform1uiv");
-            ProgramUniform2f = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLfloat, GLfloat)) resolve("glProgramUniform2f");
-            ProgramUniform2fv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, const GLfloat *)) resolve("glProgramUniform2fv");
-            ProgramUniform2i = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLint, GLint)) resolve("glProgramUniform2i");
-            ProgramUniform2iv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, const GLint *)) resolve("glProgramUniform2iv");
-            ProgramUniform2ui = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLuint, GLuint)) resolve("glProgramUniform2ui");
-            ProgramUniform2uiv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, const GLuint *)) resolve("glProgramUniform2uiv");
-            ProgramUniform3f = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLfloat, GLfloat, GLfloat)) resolve("glProgramUniform3f");
-            ProgramUniform3fv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, const GLfloat *)) resolve("glProgramUniform3fv");
-            ProgramUniform3i = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLint, GLint, GLint)) resolve("glProgramUniform3i");
-            ProgramUniform3iv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, const GLint *)) resolve("glProgramUniform3iv");
-            ProgramUniform3ui = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLuint, GLuint, GLuint)) resolve("glProgramUniform3ui");
-            ProgramUniform3uiv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, const GLuint *)) resolve("glProgramUniform3uiv");
-            ProgramUniform4f = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLfloat, GLfloat, GLfloat, GLfloat)) resolve("glProgramUniform4f");
-            ProgramUniform4fv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, const GLfloat *)) resolve("glProgramUniform4fv");
-            ProgramUniform4i = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLint, GLint, GLint, GLint)) resolve("glProgramUniform4i");
-            ProgramUniform4iv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, const GLint *)) resolve("glProgramUniform4iv");
-            ProgramUniform4ui = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLuint, GLuint, GLuint, GLuint)) resolve("glProgramUniform4ui");
-            ProgramUniform4uiv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, const GLuint *)) resolve("glProgramUniform4uiv");
-            ProgramUniformMatrix2fv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, GLboolean, const GLfloat *)) resolve("glProgramUniformMatrix2fv");
-            ProgramUniformMatrix2x3fv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, GLboolean, const GLfloat *)) resolve("glProgramUniformMatrix2x3fv");
-            ProgramUniformMatrix2x4fv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, GLboolean, const GLfloat *)) resolve("glProgramUniformMatrix2x4fv");
-            ProgramUniformMatrix3fv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, GLboolean, const GLfloat *)) resolve("glProgramUniformMatrix3fv");
-            ProgramUniformMatrix3x2fv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, GLboolean, const GLfloat *)) resolve("glProgramUniformMatrix3x2fv");
-            ProgramUniformMatrix3x4fv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, GLboolean, const GLfloat *)) resolve("glProgramUniformMatrix3x4fv");
-            ProgramUniformMatrix4fv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, GLboolean, const GLfloat *)) resolve("glProgramUniformMatrix4fv");
-            ProgramUniformMatrix4x2fv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, GLboolean, const GLfloat *)) resolve("glProgramUniformMatrix4x2fv");
-            ProgramUniformMatrix4x3fv = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLsizei, GLboolean, const GLfloat *)) resolve("glProgramUniformMatrix4x3fv");
-            SampleMaski = (void (QOPENGLF_APIENTRYP) (GLuint, GLbitfield)) resolve("glSampleMaski");
-            TexStorage2DMultisample = (void (QOPENGLF_APIENTRYP) (GLenum, GLsizei, GLenum, GLsizei, GLsizei, GLboolean)) resolve("glTexStorage2DMultisample");
-            UseProgramStages = (void (QOPENGLF_APIENTRYP) (GLuint, GLbitfield, GLuint)) resolve("glUseProgramStages");
-            ValidateProgramPipeline = (void (QOPENGLF_APIENTRYP) (GLuint)) resolve("glValidateProgramPipeline");
-            VertexAttribBinding = (void (QOPENGLF_APIENTRYP) (GLuint, GLuint)) resolve("glVertexAttribBinding");
-            VertexAttribFormat = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLenum, GLboolean, GLuint)) resolve("glVertexAttribFormat");
-            VertexAttribIFormat = (void (QOPENGLF_APIENTRYP) (GLuint, GLint, GLenum, GLuint)) resolve("glVertexAttribIFormat");
-            VertexBindingDivisor = (void (QOPENGLF_APIENTRYP) (GLuint, GLuint)) resolve("glVertexBindingDivisor");
-
-            if (!ActiveShaderProgram || !BindImageTexture || !DispatchCompute || !DrawArraysIndirect
-                || !GenProgramPipelines || !MemoryBarrierFunc) {
-                qWarning("OpenGL ES 3.1 entry points not found. This is odd because the driver returned a context of version %d.%d",
-                         contextVersion.first, contextVersion.second);
-                return;
-            }
-            m_supportedVersion = qMakePair(3, 1);
-        }
-    }
-}
-
-// GLES 3.0 and 3.1
-
-// Checks for true OpenGL ES 3.x. OpenGL with GL_ARB_ES3_compatibility
-// does not count because there the plain resolvers work anyhow.
-static inline bool isES3(int minor)
-{
-    QOpenGLContext *ctx = QOpenGLContext::currentContext();
-
-    const bool libMatches = QOpenGLContext::openGLModuleType() == QOpenGLContext::LibGLES;
-    const bool contextMatches = ctx->isOpenGLES() && ctx->format().version() >= qMakePair(3, minor);
-
-    // Resolving happens whenever qgles3Helper() is called first. So do it only
-    // when the driver gives a 3.0+ context.
-    if (libMatches && contextMatches)
-        return qgles3Helper()->supportedVersion() >= qMakePair(3, minor);
-
-    return false;
-}
-
-// Go through the dlsym-based helper for real ES 3, resolve using
-// wglGetProcAddress or similar when on plain OpenGL.
-
-static void QOPENGLF_APIENTRY qopenglfResolveBeginQuery(GLenum target, GLuint id)
-{
-    if (isES3(0))
-        qgles3Helper()->BeginQuery(target, id);
-    else
-        RESOLVE_FUNC_VOID(0, BeginQuery)(target, id);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBeginTransformFeedback(GLenum primitiveMode)
-{
-    if (isES3(0))
-        qgles3Helper()->BeginTransformFeedback(primitiveMode);
-    else
-        RESOLVE_FUNC_VOID(0, BeginTransformFeedback)(primitiveMode);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBindBufferBase(GLenum target, GLuint index, GLuint buffer)
-{
-    if (isES3(0))
-        qgles3Helper()->BindBufferBase(target, index, buffer);
-    else
-        RESOLVE_FUNC_VOID(0, BindBufferBase)(target, index, buffer);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
-{
-    if (isES3(0))
-        qgles3Helper()->BindBufferRange(target, index, buffer, offset, size);
-    else
-        RESOLVE_FUNC_VOID(0, BindBufferRange)(target, index, buffer, offset, size);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBindSampler(GLuint unit, GLuint sampler)
-{
-    if (isES3(0))
-        qgles3Helper()->BindSampler(unit, sampler);
-    else
-        RESOLVE_FUNC_VOID(0, BindSampler)(unit, sampler);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBindTransformFeedback(GLenum target, GLuint id)
-{
-    if (isES3(0))
-        qgles3Helper()->BindTransformFeedback(target, id);
-    else
-        RESOLVE_FUNC_VOID(0, BindTransformFeedback)(target, id);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBindVertexArray(GLuint array)
-{
-    if (isES3(0))
-        qgles3Helper()->BindVertexArray(array);
-    else
-        RESOLVE_FUNC_VOID(0, BindVertexArray)(array);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
-{
-    if (isES3(0))
-        qgles3Helper()->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-    else
-        RESOLVE_FUNC_VOID(ResolveEXT | ResolveANGLE | ResolveNV, BlitFramebuffer)
-            (srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
-{
-    if (isES3(0))
-        qgles3Helper()->ClearBufferfi(buffer, drawbuffer, depth, stencil);
-    else
-        RESOLVE_FUNC_VOID(0, ClearBufferfi)(buffer, drawbuffer, depth, stencil);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat * value)
-{
-    if (isES3(0))
-        qgles3Helper()->ClearBufferfv(buffer, drawbuffer, value);
-    else
-        RESOLVE_FUNC_VOID(0, ClearBufferfv)(buffer, drawbuffer, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint * value)
-{
-    if (isES3(0))
-        qgles3Helper()->ClearBufferiv(buffer, drawbuffer, value);
-    else
-        RESOLVE_FUNC_VOID(0, ClearBufferiv)(buffer, drawbuffer, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint * value)
-{
-    if (isES3(0))
-        qgles3Helper()->ClearBufferuiv(buffer, drawbuffer, value);
-    else
-        RESOLVE_FUNC_VOID(0, ClearBufferuiv)(buffer, drawbuffer, value);
-}
-
-static GLenum QOPENGLF_APIENTRY qopenglfResolveClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    if (isES3(0))
-        return qgles3Helper()->ClientWaitSync(sync, flags, timeout);
-    else
-        RESOLVE_FUNC(GLenum, 0, ClientWaitSync)(sync, flags, timeout);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void * data)
-{
-    if (isES3(0))
-        qgles3Helper()->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
-    else
-        RESOLVE_FUNC_VOID(0, CompressedTexImage3D)(target, level, internalformat, width, height, depth, border, imageSize, data);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void * data)
-{
-    if (isES3(0))
-        qgles3Helper()->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-    else
-        RESOLVE_FUNC_VOID(0, CompressedTexSubImage3D)(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
-{
-    if (isES3(0))
-        qgles3Helper()->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
-    else
-        RESOLVE_FUNC_VOID(0, CopyBufferSubData)(readTarget, writeTarget, readOffset, writeOffset, size);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    if (isES3(0))
-        qgles3Helper()->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-    else
-        RESOLVE_FUNC_VOID(0, CopyTexSubImage3D)(target, level, xoffset, yoffset, zoffset, x, y, width, height);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDeleteQueries(GLsizei n, const GLuint * ids)
-{
-    if (isES3(0))
-        qgles3Helper()->DeleteQueries(n, ids);
-    else
-        RESOLVE_FUNC_VOID(0, DeleteQueries)(n, ids);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDeleteSamplers(GLsizei count, const GLuint * samplers)
-{
-    if (isES3(0))
-        qgles3Helper()->DeleteSamplers(count, samplers);
-    else
-        RESOLVE_FUNC_VOID(0, DeleteSamplers)(count, samplers);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDeleteSync(GLsync sync)
-{
-    if (isES3(0))
-        qgles3Helper()->DeleteSync(sync);
-    else
-        RESOLVE_FUNC_VOID(0, DeleteSync)(sync);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDeleteTransformFeedbacks(GLsizei n, const GLuint * ids)
-{
-    if (isES3(0))
-        qgles3Helper()->DeleteTransformFeedbacks(n, ids);
-    else
-        RESOLVE_FUNC_VOID(0, DeleteTransformFeedbacks)(n, ids);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDeleteVertexArrays(GLsizei n, const GLuint * arrays)
-{
-    if (isES3(0))
-        qgles3Helper()->DeleteVertexArrays(n, arrays);
-    else
-        RESOLVE_FUNC_VOID(0, DeleteVertexArrays)(n, arrays);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
-{
-    if (isES3(0))
-        qgles3Helper()->DrawArraysInstanced(mode, first, count, instancecount);
-    else
-        RESOLVE_FUNC_VOID(0, DrawArraysInstanced)(mode, first, count, instancecount);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDrawBuffers(GLsizei n, const GLenum * bufs)
-{
-    if (isES3(0))
-        qgles3Helper()->DrawBuffers(n, bufs);
-    else
-        RESOLVE_FUNC_VOID(0, DrawBuffers)(n, bufs);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void * indices, GLsizei instancecount)
-{
-    if (isES3(0))
-        qgles3Helper()->DrawElementsInstanced(mode, count, type, indices, instancecount);
-    else
-        RESOLVE_FUNC_VOID(0, DrawElementsInstanced)(mode, count, type, indices, instancecount);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void * indices)
-{
-    if (isES3(0))
-        qgles3Helper()->DrawRangeElements(mode, start, end, count, type, indices);
-    else
-        RESOLVE_FUNC_VOID(0, DrawRangeElements)(mode, start, end, count, type, indices);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveEndQuery(GLenum target)
-{
-    if (isES3(0))
-        qgles3Helper()->EndQuery(target);
-    else
-        RESOLVE_FUNC_VOID(0, EndQuery)(target);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveEndTransformFeedback()
-{
-    if (isES3(0))
-        qgles3Helper()->EndTransformFeedback();
-    else
-        RESOLVE_FUNC_VOID(0, EndTransformFeedback)();
-}
-
-static GLsync QOPENGLF_APIENTRY qopenglfResolveFenceSync(GLenum condition, GLbitfield flags)
-{
-    if (isES3(0))
-        return qgles3Helper()->FenceSync(condition, flags);
-    else
-        RESOLVE_FUNC(GLsync, 0, FenceSync)(condition, flags);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
-{
-    if (isES3(0))
-        qgles3Helper()->FlushMappedBufferRange(target, offset, length);
-    else
-        RESOLVE_FUNC_VOID(0, FlushMappedBufferRange)(target, offset, length);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
-{
-    if (isES3(0))
-        qgles3Helper()->FramebufferTextureLayer(target, attachment, texture, level, layer);
-    else
-        RESOLVE_FUNC_VOID(0, FramebufferTextureLayer)(target, attachment, texture, level, layer);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGenQueries(GLsizei n, GLuint* ids)
-{
-    if (isES3(0))
-        qgles3Helper()->GenQueries(n, ids);
-    else
-        RESOLVE_FUNC_VOID(0, GenQueries)(n, ids);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGenSamplers(GLsizei count, GLuint* samplers)
-{
-    if (isES3(0))
-        qgles3Helper()->GenSamplers(count, samplers);
-    else
-        RESOLVE_FUNC_VOID(0, GenSamplers)(count, samplers);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGenTransformFeedbacks(GLsizei n, GLuint* ids)
-{
-    if (isES3(0))
-        qgles3Helper()->GenTransformFeedbacks(n, ids);
-    else
-        RESOLVE_FUNC_VOID(0, GenTransformFeedbacks)(n, ids);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGenVertexArrays(GLsizei n, GLuint* arrays)
-{
-    if (isES3(0))
-        qgles3Helper()->GenVertexArrays(n, arrays);
-    else
-        RESOLVE_FUNC_VOID(0, GenVertexArrays)(n, arrays);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei* length, GLchar* uniformBlockName)
-{
-    if (isES3(0))
-        qgles3Helper()->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-    else
-        RESOLVE_FUNC_VOID(0, GetActiveUniformBlockName)(program, uniformBlockIndex, bufSize, length, uniformBlockName);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint* params)
-{
-    if (isES3(0))
-        qgles3Helper()->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetActiveUniformBlockiv)(program, uniformBlockIndex, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint * uniformIndices, GLenum pname, GLint* params)
-{
-    if (isES3(0))
-        qgles3Helper()->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetActiveUniformsiv)(program, uniformCount, uniformIndices, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetBufferParameteri64v(GLenum target, GLenum pname, GLint64* params)
-{
-    if (isES3(0))
-        qgles3Helper()->GetBufferParameteri64v(target, pname, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetBufferParameteri64v)(target, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetBufferPointerv(GLenum target, GLenum pname, void ** params)
-{
-    if (isES3(0))
-        qgles3Helper()->GetBufferPointerv(target, pname, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetBufferPointerv)(target, pname, params);
-}
-
-static GLint QOPENGLF_APIENTRY qopenglfResolveGetFragDataLocation(GLuint program, const GLchar * name)
-{
-    if (isES3(0))
-        return qgles3Helper()->GetFragDataLocation(program, name);
-    else
-        RESOLVE_FUNC(GLint, 0, GetFragDataLocation)(program, name);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetInteger64i_v(GLenum target, GLuint index, GLint64* data)
-{
-    if (isES3(0))
-        qgles3Helper()->GetInteger64i_v(target, index, data);
-    else
-        RESOLVE_FUNC_VOID(0, GetInteger64i_v)(target, index, data);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetInteger64v(GLenum pname, GLint64* data)
-{
-    if (isES3(0))
-        qgles3Helper()->GetInteger64v(pname, data);
-    else
-        RESOLVE_FUNC_VOID(0, GetInteger64v)(pname, data);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetIntegeri_v(GLenum target, GLuint index, GLint* data)
-{
-    if (isES3(0))
-        qgles3Helper()->GetIntegeri_v(target, index, data);
-    else
-        RESOLVE_FUNC_VOID(0, GetIntegeri_v)(target, index, data);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint* params)
-{
-    if (isES3(0))
-        qgles3Helper()->GetInternalformativ(target, internalformat, pname, bufSize, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetInternalformativ)(target, internalformat, pname, bufSize, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, void * binary)
-{
-    if (isES3(0))
-        qgles3Helper()->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
-    else
-        RESOLVE_FUNC_VOID(0, GetProgramBinary)(program, bufSize, length, binaryFormat, binary);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetQueryObjectuiv(GLuint id, GLenum pname, GLuint* params)
-{
-    if (isES3(0))
-        qgles3Helper()->GetQueryObjectuiv(id, pname, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetQueryObjectuiv)(id, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetQueryiv(GLenum target, GLenum pname, GLint* params)
-{
-    if (isES3(0))
-        qgles3Helper()->GetQueryiv(target, pname, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetQueryiv)(target, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat* params)
-{
-    if (isES3(0))
-        qgles3Helper()->GetSamplerParameterfv(sampler, pname, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetSamplerParameterfv)(sampler, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint* params)
-{
-    if (isES3(0))
-        qgles3Helper()->GetSamplerParameteriv(sampler, pname, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetSamplerParameteriv)(sampler, pname, params);
-}
-
-static const GLubyte * QOPENGLF_APIENTRY qopenglfResolveGetStringi(GLenum name, GLuint index)
-{
-    if (isES3(0))
-        return qgles3Helper()->GetStringi(name, index);
-    else
-        RESOLVE_FUNC(const GLubyte *, 0, GetStringi)(name, index);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei* length, GLint* values)
-{
-    if (isES3(0))
-        qgles3Helper()->GetSynciv(sync, pname, bufSize, length, values);
-    else
-        RESOLVE_FUNC_VOID(0, GetSynciv)(sync, pname, bufSize, length, values);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei* length, GLsizei* size, GLenum* type, GLchar* name)
-{
-    if (isES3(0))
-        qgles3Helper()->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
-    else
-        RESOLVE_FUNC_VOID(0, GetTransformFeedbackVarying)(program, index, bufSize, length, size, type, name);
-}
-
-static GLuint QOPENGLF_APIENTRY qopenglfResolveGetUniformBlockIndex(GLuint program, const GLchar * uniformBlockName)
-{
-    if (isES3(0))
-        return qgles3Helper()->GetUniformBlockIndex(program, uniformBlockName);
-    else
-        RESOLVE_FUNC(GLuint, 0, GetUniformBlockIndex)(program, uniformBlockName);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const* uniformNames, GLuint* uniformIndices)
-{
-    if (isES3(0))
-        qgles3Helper()->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
-    else
-        RESOLVE_FUNC_VOID(0, GetUniformIndices)(program, uniformCount, uniformNames, uniformIndices);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetUniformuiv(GLuint program, GLint location, GLuint* params)
-{
-    if (isES3(0))
-        qgles3Helper()->GetUniformuiv(program, location, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetUniformuiv)(program, location, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetVertexAttribIiv(GLuint index, GLenum pname, GLint* params)
-{
-    if (isES3(0))
-        qgles3Helper()->GetVertexAttribIiv(index, pname, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetVertexAttribIiv)(index, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint* params)
-{
-    if (isES3(0))
-        qgles3Helper()->GetVertexAttribIuiv(index, pname, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetVertexAttribIuiv)(index, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum * attachments)
-{
-    if (isES3(0))
-        qgles3Helper()->InvalidateFramebuffer(target, numAttachments, attachments);
-    else
-        RESOLVE_FUNC_VOID(0, InvalidateFramebuffer)(target, numAttachments, attachments);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum * attachments, GLint x, GLint y, GLsizei width, GLsizei height)
-{
-    if (isES3(0))
-        qgles3Helper()->InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
-    else
-        RESOLVE_FUNC_VOID(0, InvalidateSubFramebuffer)(target, numAttachments, attachments, x, y, width, height);
-}
-
-static GLboolean QOPENGLF_APIENTRY qopenglfResolveIsQuery(GLuint id)
-{
-    if (isES3(0))
-        return qgles3Helper()->IsQuery(id);
-    else
-        RESOLVE_FUNC(GLboolean, 0, IsQuery)(id);
-}
-
-static GLboolean QOPENGLF_APIENTRY qopenglfResolveIsSampler(GLuint sampler)
-{
-    if (isES3(0))
-        return qgles3Helper()->IsSampler(sampler);
-    else
-        RESOLVE_FUNC(GLboolean, 0, IsSampler)(sampler);
-}
-
-static GLboolean QOPENGLF_APIENTRY qopenglfResolveIsSync(GLsync sync)
-{
-    if (isES3(0))
-        return qgles3Helper()->IsSync(sync);
-    else
-        RESOLVE_FUNC(GLboolean, 0, IsSync)(sync);
-}
-
-static GLboolean QOPENGLF_APIENTRY qopenglfResolveIsTransformFeedback(GLuint id)
-{
-    if (isES3(0))
-        return qgles3Helper()->IsTransformFeedback(id);
-    else
-        RESOLVE_FUNC(GLboolean, 0, IsTransformFeedback)(id);
-}
-
-static GLboolean QOPENGLF_APIENTRY qopenglfResolveIsVertexArray(GLuint array)
-{
-    if (isES3(0))
-        return qgles3Helper()->IsVertexArray(array);
-    else
-        RESOLVE_FUNC(GLboolean, 0, IsVertexArray)(array);
-}
-
-static void * QOPENGLF_APIENTRY qopenglfResolveMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
-{
-    if (isES3(0))
-        return qgles3Helper()->MapBufferRange(target, offset, length, access);
-    else
-        RESOLVE_FUNC(void *, 0, MapBufferRange)(target, offset, length, access);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolvePauseTransformFeedback()
-{
-    if (isES3(0))
-        qgles3Helper()->PauseTransformFeedback();
-    else
-        RESOLVE_FUNC_VOID(0, PauseTransformFeedback)();
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramBinary(GLuint program, GLenum binaryFormat, const void * binary, GLsizei length)
-{
-    if (isES3(0))
-        qgles3Helper()->ProgramBinary(program, binaryFormat, binary, length);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramBinary)(program, binaryFormat, binary, length);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramParameteri(GLuint program, GLenum pname, GLint value)
-{
-    if (isES3(0))
-        qgles3Helper()->ProgramParameteri(program, pname, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramParameteri)(program, pname, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveReadBuffer(GLenum src)
-{
-    if (isES3(0))
-        qgles3Helper()->ReadBuffer(src);
-    else
-        RESOLVE_FUNC_VOID(0, ReadBuffer)(src);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    if (isES3(0))
-        qgles3Helper()->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
-    else
-        RESOLVE_FUNC_VOID(ResolveEXT | ResolveANGLE | ResolveNV, RenderbufferStorageMultisample)
-            (target, samples, internalformat, width, height);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveResumeTransformFeedback()
-{
-    if (isES3(0))
-        qgles3Helper()->ResumeTransformFeedback();
-    else
-        RESOLVE_FUNC_VOID(0, ResumeTransformFeedback)();
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
-{
-    if (isES3(0))
-        qgles3Helper()->SamplerParameterf(sampler, pname, param);
-    else
-        RESOLVE_FUNC_VOID(0, SamplerParameterf)(sampler, pname, param);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat * param)
-{
-    if (isES3(0))
-        qgles3Helper()->SamplerParameterfv(sampler, pname, param);
-    else
-        RESOLVE_FUNC_VOID(0, SamplerParameterfv)(sampler, pname, param);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
-{
-    if (isES3(0))
-        qgles3Helper()->SamplerParameteri(sampler, pname, param);
-    else
-        RESOLVE_FUNC_VOID(0, SamplerParameteri)(sampler, pname, param);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveSamplerParameteriv(GLuint sampler, GLenum pname, const GLint * param)
-{
-    if (isES3(0))
-        qgles3Helper()->SamplerParameteriv(sampler, pname, param);
-    else
-        RESOLVE_FUNC_VOID(0, SamplerParameteriv)(sampler, pname, param);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void * pixels)
-{
-    if (isES3(0))
-        qgles3Helper()->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
-    else
-        RESOLVE_FUNC_VOID(0, TexImage3D)(target, level, internalformat, width, height, depth, border, format, type, pixels);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
-{
-    if (isES3(0))
-        qgles3Helper()->TexStorage2D(target, levels, internalformat, width, height);
-    else
-        RESOLVE_FUNC_VOID(0, TexStorage2D)(target, levels, internalformat, width, height);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
-{
-    if (isES3(0))
-        qgles3Helper()->TexStorage3D(target, levels, internalformat, width, height, depth);
-    else
-        RESOLVE_FUNC_VOID(0, TexStorage3D)(target, levels, internalformat, width, height, depth);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void * pixels)
-{
-    if (isES3(0))
-        qgles3Helper()->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-    else
-        RESOLVE_FUNC_VOID(0, TexSubImage3D)(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const* varyings, GLenum bufferMode)
-{
-    if (isES3(0))
-        qgles3Helper()->TransformFeedbackVaryings(program, count, varyings, bufferMode);
-    else
-        RESOLVE_FUNC_VOID(0, TransformFeedbackVaryings)(program, count, varyings, bufferMode);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform1ui(GLint location, GLuint v0)
-{
-    if (isES3(0))
-        qgles3Helper()->Uniform1ui(location, v0);
-    else
-        RESOLVE_FUNC_VOID(0, Uniform1ui)(location, v0);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform1uiv(GLint location, GLsizei count, const GLuint * value)
-{
-    if (isES3(0))
-        qgles3Helper()->Uniform1uiv(location, count, value);
-    else
-        RESOLVE_FUNC_VOID(0, Uniform1uiv)(location, count, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform2ui(GLint location, GLuint v0, GLuint v1)
-{
-    if (isES3(0))
-        qgles3Helper()->Uniform2ui(location, v0, v1);
-    else
-        RESOLVE_FUNC_VOID(0, Uniform2ui)(location, v0, v1);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform2uiv(GLint location, GLsizei count, const GLuint * value)
-{
-    if (isES3(0))
-        qgles3Helper()->Uniform2uiv(location, count, value);
-    else
-        RESOLVE_FUNC_VOID(0, Uniform2uiv)(location, count, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    if (isES3(0))
-        qgles3Helper()->Uniform3ui(location, v0, v1, v2);
-    else
-        RESOLVE_FUNC_VOID(0, Uniform3ui)(location, v0, v1, v2);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform3uiv(GLint location, GLsizei count, const GLuint * value)
-{
-    if (isES3(0))
-        qgles3Helper()->Uniform3uiv(location, count, value);
-    else
-        RESOLVE_FUNC_VOID(0, Uniform3uiv)(location, count, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    if (isES3(0))
-        qgles3Helper()->Uniform4ui(location, v0, v1, v2, v3);
-    else
-        RESOLVE_FUNC_VOID(0, Uniform4ui)(location, v0, v1, v2, v3);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniform4uiv(GLint location, GLsizei count, const GLuint * value)
-{
-    if (isES3(0))
-        qgles3Helper()->Uniform4uiv(location, count, value);
-    else
-        RESOLVE_FUNC_VOID(0, Uniform4uiv)(location, count, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
-{
-    if (isES3(0))
-        qgles3Helper()->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
-    else
-        RESOLVE_FUNC_VOID(0, UniformBlockBinding)(program, uniformBlockIndex, uniformBlockBinding);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
-{
-    if (isES3(0))
-        qgles3Helper()->UniformMatrix2x3fv(location, count, transpose, value);
-    else
-        RESOLVE_FUNC_VOID(0, UniformMatrix2x3fv)(location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
-{
-    if (isES3(0))
-        qgles3Helper()->UniformMatrix2x4fv(location, count, transpose, value);
-    else
-        RESOLVE_FUNC_VOID(0, UniformMatrix2x4fv)(location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
-{
-    if (isES3(0))
-        qgles3Helper()->UniformMatrix3x2fv(location, count, transpose, value);
-    else
-        RESOLVE_FUNC_VOID(0, UniformMatrix3x2fv)(location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
-{
-    if (isES3(0))
-        qgles3Helper()->UniformMatrix3x4fv(location, count, transpose, value);
-    else
-        RESOLVE_FUNC_VOID(0, UniformMatrix3x4fv)(location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
-{
-    if (isES3(0))
-        qgles3Helper()->UniformMatrix4x2fv(location, count, transpose, value);
-    else
-        RESOLVE_FUNC_VOID(0, UniformMatrix4x2fv)(location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
-{
-    if (isES3(0))
-        qgles3Helper()->UniformMatrix4x3fv(location, count, transpose, value);
-    else
-        RESOLVE_FUNC_VOID(0, UniformMatrix4x3fv)(location, count, transpose, value);
-}
-
-static GLboolean QOPENGLF_APIENTRY qopenglfResolveUnmapBuffer(GLenum target)
-{
-    if (isES3(0))
-        return qgles3Helper()->UnmapBuffer(target);
-    else
-        RESOLVE_FUNC(GLboolean, ResolveOES, UnmapBuffer)(target);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttribDivisor(GLuint index, GLuint divisor)
-{
-    if (isES3(0))
-        qgles3Helper()->VertexAttribDivisor(index, divisor);
-    else
-        RESOLVE_FUNC_VOID(0, VertexAttribDivisor)(index, divisor);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
-{
-    if (isES3(0))
-        qgles3Helper()->VertexAttribI4i(index, x, y, z, w);
-    else
-        RESOLVE_FUNC_VOID(0, VertexAttribI4i)(index, x, y, z, w);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttribI4iv(GLuint index, const GLint * v)
-{
-    if (isES3(0))
-        qgles3Helper()->VertexAttribI4iv(index, v);
-    else
-        RESOLVE_FUNC_VOID(0, VertexAttribI4iv)(index, v);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
-{
-    if (isES3(0))
-        qgles3Helper()->VertexAttribI4ui(index, x, y, z, w);
-    else
-        RESOLVE_FUNC_VOID(0, VertexAttribI4ui)(index, x, y, z, w);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttribI4uiv(GLuint index, const GLuint * v)
-{
-    if (isES3(0))
-        qgles3Helper()->VertexAttribI4uiv(index, v);
-    else
-        RESOLVE_FUNC_VOID(0, VertexAttribI4uiv)(index, v);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void * pointer)
-{
-    if (isES3(0))
-        qgles3Helper()->VertexAttribIPointer(index, size, type, stride, pointer);
-    else
-        RESOLVE_FUNC_VOID(0, VertexAttribIPointer)(index, size, type, stride, pointer);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
-{
-    if (isES3(0))
-        qgles3Helper()->WaitSync(sync, flags, timeout);
-    else
-        RESOLVE_FUNC_VOID(0, WaitSync)(sync, flags, timeout);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveActiveShaderProgram(GLuint pipeline, GLuint program)
-{
-    if (isES3(1))
-        qgles3Helper()->ActiveShaderProgram(pipeline, program);
-    else
-        RESOLVE_FUNC_VOID(0, ActiveShaderProgram)(pipeline, program);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
-{
-    if (isES3(1))
-        qgles3Helper()->BindImageTexture(unit, texture, level, layered, layer, access, format);
-    else
-        RESOLVE_FUNC_VOID(0, BindImageTexture)(unit, texture, level, layered, layer, access, format);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBindProgramPipeline(GLuint pipeline)
-{
-    if (isES3(1))
-        qgles3Helper()->BindProgramPipeline(pipeline);
-    else
-        RESOLVE_FUNC_VOID(0, BindProgramPipeline)(pipeline);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
-{
-    if (isES3(1))
-        qgles3Helper()->BindVertexBuffer(bindingindex, buffer, offset, stride);
-    else
-        RESOLVE_FUNC_VOID(0, BindVertexBuffer)(bindingindex, buffer, offset, stride);
-}
-
-static GLuint QOPENGLF_APIENTRY qopenglfResolveCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const* strings)
-{
-    if (isES3(1))
-        return qgles3Helper()->CreateShaderProgramv(type, count, strings);
-    else
-        RESOLVE_FUNC(GLuint, 0, CreateShaderProgramv)(type, count, strings);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDeleteProgramPipelines(GLsizei n, const GLuint * pipelines)
-{
-    if (isES3(1))
-        qgles3Helper()->DeleteProgramPipelines(n, pipelines);
-    else
-        RESOLVE_FUNC_VOID(0, DeleteProgramPipelines)(n, pipelines);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
-{
-    if (isES3(1))
-        qgles3Helper()->DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
-    else
-        RESOLVE_FUNC_VOID(0, DispatchCompute)(num_groups_x, num_groups_y, num_groups_z);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDispatchComputeIndirect(GLintptr indirect)
-{
-    if (isES3(1))
-        qgles3Helper()->DispatchComputeIndirect(indirect);
-    else
-        RESOLVE_FUNC_VOID(0, DispatchComputeIndirect)(indirect);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDrawArraysIndirect(GLenum mode, const void * indirect)
-{
-    if (isES3(1))
-        qgles3Helper()->DrawArraysIndirect(mode, indirect);
-    else
-        RESOLVE_FUNC_VOID(0, DrawArraysIndirect)(mode, indirect);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveDrawElementsIndirect(GLenum mode, GLenum type, const void * indirect)
-{
-    if (isES3(1))
-        qgles3Helper()->DrawElementsIndirect(mode, type, indirect);
-    else
-        RESOLVE_FUNC_VOID(0, DrawElementsIndirect)(mode, type, indirect);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveFramebufferParameteri(GLenum target, GLenum pname, GLint param)
-{
-    if (isES3(1))
-        qgles3Helper()->FramebufferParameteri(target, pname, param);
-    else
-        RESOLVE_FUNC_VOID(0, FramebufferParameteri)(target, pname, param);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGenProgramPipelines(GLsizei n, GLuint* pipelines)
-{
-    if (isES3(1))
-        qgles3Helper()->GenProgramPipelines(n, pipelines);
-    else
-        RESOLVE_FUNC_VOID(0, GenProgramPipelines)(n, pipelines);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetBooleani_v(GLenum target, GLuint index, GLboolean* data)
-{
-    if (isES3(1))
-        qgles3Helper()->GetBooleani_v(target, index, data);
-    else
-        RESOLVE_FUNC_VOID(0, GetBooleani_v)(target, index, data);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetFramebufferParameteriv(GLenum target, GLenum pname, GLint* params)
-{
-    if (isES3(1))
-        qgles3Helper()->GetFramebufferParameteriv(target, pname, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetFramebufferParameteriv)(target, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetMultisamplefv(GLenum pname, GLuint index, GLfloat* val)
-{
-    if (isES3(1))
-        qgles3Helper()->GetMultisamplefv(pname, index, val);
-    else
-        RESOLVE_FUNC_VOID(0, GetMultisamplefv)(pname, index, val);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint* params)
-{
-    if (isES3(1))
-        qgles3Helper()->GetProgramInterfaceiv(program, programInterface, pname, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetProgramInterfaceiv)(program, programInterface, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei* length, GLchar* infoLog)
-{
-    if (isES3(1))
-        qgles3Helper()->GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
-    else
-        RESOLVE_FUNC_VOID(0, GetProgramPipelineInfoLog)(pipeline, bufSize, length, infoLog);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint* params)
-{
-    if (isES3(1))
-        qgles3Helper()->GetProgramPipelineiv(pipeline, pname, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetProgramPipelineiv)(pipeline, pname, params);
-}
-
-static GLuint QOPENGLF_APIENTRY qopenglfResolveGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar * name)
-{
-    if (isES3(1))
-        return qgles3Helper()->GetProgramResourceIndex(program, programInterface, name);
-    else
-        RESOLVE_FUNC(GLuint, 0, GetProgramResourceIndex)(program, programInterface, name);
-}
-
-static GLint QOPENGLF_APIENTRY qopenglfResolveGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar * name)
-{
-    if (isES3(1))
-        return qgles3Helper()->GetProgramResourceLocation(program, programInterface, name);
-    else
-        RESOLVE_FUNC(GLint, 0, GetProgramResourceLocation)(program, programInterface, name);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei* length, GLchar* name)
-{
-    if (isES3(1))
-        qgles3Helper()->GetProgramResourceName(program, programInterface, index, bufSize, length, name);
-    else
-        RESOLVE_FUNC_VOID(0, GetProgramResourceName)(program, programInterface, index, bufSize, length, name);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum * props, GLsizei bufSize, GLsizei* length, GLint* params)
-{
-    if (isES3(1))
-        qgles3Helper()->GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetProgramResourceiv)(program, programInterface, index, propCount, props, bufSize, length, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat* params)
-{
-    if (isES3(1))
-        qgles3Helper()->GetTexLevelParameterfv(target, level, pname, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetTexLevelParameterfv)(target, level, pname, params);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint* params)
-{
-    if (isES3(1))
-        qgles3Helper()->GetTexLevelParameteriv(target, level, pname, params);
-    else
-        RESOLVE_FUNC_VOID(0, GetTexLevelParameteriv)(target, level, pname, params);
-}
-
-static GLboolean QOPENGLF_APIENTRY qopenglfResolveIsProgramPipeline(GLuint pipeline)
-{
-    if (isES3(1))
-        return qgles3Helper()->IsProgramPipeline(pipeline);
-    else
-        RESOLVE_FUNC(GLboolean, 0, IsProgramPipeline)(pipeline);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveMemoryBarrier(GLbitfield barriers)
-{
-    if (isES3(1))
-        qgles3Helper()->MemoryBarrierFunc(barriers);
-    else
-        RESOLVE_FUNC_VOID(0, MemoryBarrierFunc)(barriers);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveMemoryBarrierByRegion(GLbitfield barriers)
-{
-    if (isES3(1))
-        qgles3Helper()->MemoryBarrierByRegion(barriers);
-    else
-        RESOLVE_FUNC_VOID(0, MemoryBarrierByRegion)(barriers);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform1f(GLuint program, GLint location, GLfloat v0)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform1f(program, location, v0);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform1f)(program, location, v0);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform1fv(program, location, count, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform1fv)(program, location, count, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform1i(GLuint program, GLint location, GLint v0)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform1i(program, location, v0);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform1i)(program, location, v0);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform1iv(program, location, count, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform1iv)(program, location, count, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform1ui(GLuint program, GLint location, GLuint v0)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform1ui(program, location, v0);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform1ui)(program, location, v0);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform1uiv(program, location, count, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform1uiv)(program, location, count, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform2f(program, location, v0, v1);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform2f)(program, location, v0, v1);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform2fv(program, location, count, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform2fv)(program, location, count, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform2i(program, location, v0, v1);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform2i)(program, location, v0, v1);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform2iv(program, location, count, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform2iv)(program, location, count, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform2ui(program, location, v0, v1);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform2ui)(program, location, v0, v1);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform2uiv(program, location, count, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform2uiv)(program, location, count, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform3f(program, location, v0, v1, v2);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform3f)(program, location, v0, v1, v2);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform3fv(program, location, count, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform3fv)(program, location, count, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform3i(program, location, v0, v1, v2);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform3i)(program, location, v0, v1, v2);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform3iv(program, location, count, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform3iv)(program, location, count, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform3ui(program, location, v0, v1, v2);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform3ui)(program, location, v0, v1, v2);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform3uiv(program, location, count, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform3uiv)(program, location, count, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform4f(program, location, v0, v1, v2, v3);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform4f)(program, location, v0, v1, v2, v3);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform4fv(program, location, count, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform4fv)(program, location, count, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform4i(program, location, v0, v1, v2, v3);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform4i)(program, location, v0, v1, v2, v3);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform4iv(program, location, count, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform4iv)(program, location, count, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform4ui(program, location, v0, v1, v2, v3);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform4ui)(program, location, v0, v1, v2, v3);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniform4uiv(program, location, count, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniform4uiv)(program, location, count, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniformMatrix2fv(program, location, count, transpose, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniformMatrix2fv)(program, location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniformMatrix2x3fv)(program, location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniformMatrix2x4fv)(program, location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniformMatrix3fv(program, location, count, transpose, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniformMatrix3fv)(program, location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniformMatrix3x2fv)(program, location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniformMatrix3x4fv)(program, location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniformMatrix4fv(program, location, count, transpose, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniformMatrix4fv)(program, location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniformMatrix4x2fv)(program, location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat * value)
-{
-    if (isES3(1))
-        qgles3Helper()->ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
-    else
-        RESOLVE_FUNC_VOID(0, ProgramUniformMatrix4x3fv)(program, location, count, transpose, value);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveSampleMaski(GLuint maskNumber, GLbitfield mask)
-{
-    if (isES3(1))
-        qgles3Helper()->SampleMaski(maskNumber, mask);
-    else
-        RESOLVE_FUNC_VOID(0, SampleMaski)(maskNumber, mask);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
-{
-    if (isES3(1))
-        qgles3Helper()->TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
-    else
-        RESOLVE_FUNC_VOID(0, TexStorage2DMultisample)(target, samples, internalformat, width, height, fixedsamplelocations);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
-{
-    if (isES3(1))
-        qgles3Helper()->UseProgramStages(pipeline, stages, program);
-    else
-        RESOLVE_FUNC_VOID(0, UseProgramStages)(pipeline, stages, program);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveValidateProgramPipeline(GLuint pipeline)
-{
-    if (isES3(1))
-        qgles3Helper()->ValidateProgramPipeline(pipeline);
-    else
-        RESOLVE_FUNC_VOID(0, ValidateProgramPipeline)(pipeline);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
-{
-    if (isES3(1))
-        qgles3Helper()->VertexAttribBinding(attribindex, bindingindex);
-    else
-        RESOLVE_FUNC_VOID(0, VertexAttribBinding)(attribindex, bindingindex);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
-{
-    if (isES3(1))
-        qgles3Helper()->VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
-    else
-        RESOLVE_FUNC_VOID(0, VertexAttribFormat)(attribindex, size, type, normalized, relativeoffset);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
-{
-    if (isES3(1))
-        qgles3Helper()->VertexAttribIFormat(attribindex, size, type, relativeoffset);
-    else
-        RESOLVE_FUNC_VOID(0, VertexAttribIFormat)(attribindex, size, type, relativeoffset);
-}
-
-static void QOPENGLF_APIENTRY qopenglfResolveVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
-{
-    if (isES3(1))
-        qgles3Helper()->VertexBindingDivisor(bindingindex, divisor);
-    else
-        RESOLVE_FUNC_VOID(0, VertexBindingDivisor)(bindingindex, divisor);
-}
 
 /*!
     Constructs a default function resolver. The resolver cannot be used until
@@ -7402,194 +4500,21 @@ QOpenGLExtraFunctions::QOpenGLExtraFunctions(QOpenGLContext *context)
 QOpenGLExtraFunctionsPrivate::QOpenGLExtraFunctionsPrivate(QOpenGLContext *ctx)
     : QOpenGLFunctionsPrivate(ctx)
 {
-    ReadBuffer = qopenglfResolveReadBuffer;
-    DrawRangeElements = qopenglfResolveDrawRangeElements;
-    TexImage3D = qopenglfResolveTexImage3D;
-    TexSubImage3D = qopenglfResolveTexSubImage3D;
-    CopyTexSubImage3D = qopenglfResolveCopyTexSubImage3D;
-    CompressedTexImage3D = qopenglfResolveCompressedTexImage3D;
-    CompressedTexSubImage3D = qopenglfResolveCompressedTexSubImage3D;
-    GenQueries = qopenglfResolveGenQueries;
-    DeleteQueries = qopenglfResolveDeleteQueries;
-    IsQuery = qopenglfResolveIsQuery;
-    BeginQuery = qopenglfResolveBeginQuery;
-    EndQuery = qopenglfResolveEndQuery;
-    GetQueryiv = qopenglfResolveGetQueryiv;
-    GetQueryObjectuiv = qopenglfResolveGetQueryObjectuiv;
-    UnmapBuffer = qopenglfResolveUnmapBuffer;
-    GetBufferPointerv = qopenglfResolveGetBufferPointerv;
-    DrawBuffers = qopenglfResolveDrawBuffers;
-    UniformMatrix2x3fv = qopenglfResolveUniformMatrix2x3fv;
-    UniformMatrix3x2fv = qopenglfResolveUniformMatrix3x2fv;
-    UniformMatrix2x4fv = qopenglfResolveUniformMatrix2x4fv;
-    UniformMatrix4x2fv = qopenglfResolveUniformMatrix4x2fv;
-    UniformMatrix3x4fv = qopenglfResolveUniformMatrix3x4fv;
-    UniformMatrix4x3fv = qopenglfResolveUniformMatrix4x3fv;
-    BlitFramebuffer = qopenglfResolveBlitFramebuffer;
-    RenderbufferStorageMultisample = qopenglfResolveRenderbufferStorageMultisample;
-    FramebufferTextureLayer = qopenglfResolveFramebufferTextureLayer;
-    MapBufferRange = qopenglfResolveMapBufferRange;
-    FlushMappedBufferRange = qopenglfResolveFlushMappedBufferRange;
-    BindVertexArray = qopenglfResolveBindVertexArray;
-    DeleteVertexArrays = qopenglfResolveDeleteVertexArrays;
-    GenVertexArrays = qopenglfResolveGenVertexArrays;
-    IsVertexArray = qopenglfResolveIsVertexArray;
-    GetIntegeri_v = qopenglfResolveGetIntegeri_v;
-    BeginTransformFeedback = qopenglfResolveBeginTransformFeedback;
-    EndTransformFeedback = qopenglfResolveEndTransformFeedback;
-    BindBufferRange = qopenglfResolveBindBufferRange;
-    BindBufferBase = qopenglfResolveBindBufferBase;
-    TransformFeedbackVaryings = qopenglfResolveTransformFeedbackVaryings;
-    GetTransformFeedbackVarying = qopenglfResolveGetTransformFeedbackVarying;
-    VertexAttribIPointer = qopenglfResolveVertexAttribIPointer;
-    GetVertexAttribIiv = qopenglfResolveGetVertexAttribIiv;
-    GetVertexAttribIuiv = qopenglfResolveGetVertexAttribIuiv;
-    VertexAttribI4i = qopenglfResolveVertexAttribI4i;
-    VertexAttribI4ui = qopenglfResolveVertexAttribI4ui;
-    VertexAttribI4iv = qopenglfResolveVertexAttribI4iv;
-    VertexAttribI4uiv = qopenglfResolveVertexAttribI4uiv;
-    GetUniformuiv = qopenglfResolveGetUniformuiv;
-    GetFragDataLocation = qopenglfResolveGetFragDataLocation;
-    Uniform1ui = qopenglfResolveUniform1ui;
-    Uniform2ui = qopenglfResolveUniform2ui;
-    Uniform3ui = qopenglfResolveUniform3ui;
-    Uniform4ui = qopenglfResolveUniform4ui;
-    Uniform1uiv = qopenglfResolveUniform1uiv;
-    Uniform2uiv = qopenglfResolveUniform2uiv;
-    Uniform3uiv = qopenglfResolveUniform3uiv;
-    Uniform4uiv = qopenglfResolveUniform4uiv;
-    ClearBufferiv = qopenglfResolveClearBufferiv;
-    ClearBufferuiv = qopenglfResolveClearBufferuiv;
-    ClearBufferfv = qopenglfResolveClearBufferfv;
-    ClearBufferfi = qopenglfResolveClearBufferfi;
-    GetStringi = qopenglfResolveGetStringi;
-    CopyBufferSubData = qopenglfResolveCopyBufferSubData;
-    GetUniformIndices = qopenglfResolveGetUniformIndices;
-    GetActiveUniformsiv = qopenglfResolveGetActiveUniformsiv;
-    GetUniformBlockIndex = qopenglfResolveGetUniformBlockIndex;
-    GetActiveUniformBlockiv = qopenglfResolveGetActiveUniformBlockiv;
-    GetActiveUniformBlockName = qopenglfResolveGetActiveUniformBlockName;
-    UniformBlockBinding = qopenglfResolveUniformBlockBinding;
-    DrawArraysInstanced = qopenglfResolveDrawArraysInstanced;
-    DrawElementsInstanced = qopenglfResolveDrawElementsInstanced;
-    FenceSync = qopenglfResolveFenceSync;
-    IsSync = qopenglfResolveIsSync;
-    DeleteSync = qopenglfResolveDeleteSync;
-    ClientWaitSync = qopenglfResolveClientWaitSync;
-    WaitSync = qopenglfResolveWaitSync;
-    GetInteger64v = qopenglfResolveGetInteger64v;
-    GetSynciv = qopenglfResolveGetSynciv;
-    GetInteger64i_v = qopenglfResolveGetInteger64i_v;
-    GetBufferParameteri64v = qopenglfResolveGetBufferParameteri64v;
-    GenSamplers = qopenglfResolveGenSamplers;
-    DeleteSamplers = qopenglfResolveDeleteSamplers;
-    IsSampler = qopenglfResolveIsSampler;
-    BindSampler = qopenglfResolveBindSampler;
-    SamplerParameteri = qopenglfResolveSamplerParameteri;
-    SamplerParameteriv = qopenglfResolveSamplerParameteriv;
-    SamplerParameterf = qopenglfResolveSamplerParameterf;
-    SamplerParameterfv = qopenglfResolveSamplerParameterfv;
-    GetSamplerParameteriv = qopenglfResolveGetSamplerParameteriv;
-    GetSamplerParameterfv = qopenglfResolveGetSamplerParameterfv;
-    VertexAttribDivisor = qopenglfResolveVertexAttribDivisor;
-    BindTransformFeedback = qopenglfResolveBindTransformFeedback;
-    DeleteTransformFeedbacks = qopenglfResolveDeleteTransformFeedbacks;
-    GenTransformFeedbacks = qopenglfResolveGenTransformFeedbacks;
-    IsTransformFeedback = qopenglfResolveIsTransformFeedback;
-    PauseTransformFeedback = qopenglfResolvePauseTransformFeedback;
-    ResumeTransformFeedback = qopenglfResolveResumeTransformFeedback;
-    GetProgramBinary = qopenglfResolveGetProgramBinary;
-    ProgramBinary = qopenglfResolveProgramBinary;
-    ProgramParameteri = qopenglfResolveProgramParameteri;
-    InvalidateFramebuffer = qopenglfResolveInvalidateFramebuffer;
-    InvalidateSubFramebuffer = qopenglfResolveInvalidateSubFramebuffer;
-    TexStorage2D = qopenglfResolveTexStorage2D;
-    TexStorage3D = qopenglfResolveTexStorage3D;
-    GetInternalformativ = qopenglfResolveGetInternalformativ;
-
-    DispatchCompute = qopenglfResolveDispatchCompute;
-    DispatchComputeIndirect = qopenglfResolveDispatchComputeIndirect;
-    DrawArraysIndirect = qopenglfResolveDrawArraysIndirect;
-    DrawElementsIndirect = qopenglfResolveDrawElementsIndirect;
-    FramebufferParameteri = qopenglfResolveFramebufferParameteri;
-    GetFramebufferParameteriv = qopenglfResolveGetFramebufferParameteriv;
-    GetProgramInterfaceiv = qopenglfResolveGetProgramInterfaceiv;
-    GetProgramResourceIndex = qopenglfResolveGetProgramResourceIndex;
-    GetProgramResourceName = qopenglfResolveGetProgramResourceName;
-    GetProgramResourceiv = qopenglfResolveGetProgramResourceiv;
-    GetProgramResourceLocation = qopenglfResolveGetProgramResourceLocation;
-    UseProgramStages = qopenglfResolveUseProgramStages;
-    ActiveShaderProgram = qopenglfResolveActiveShaderProgram;
-    CreateShaderProgramv = qopenglfResolveCreateShaderProgramv;
-    BindProgramPipeline = qopenglfResolveBindProgramPipeline;
-    DeleteProgramPipelines = qopenglfResolveDeleteProgramPipelines;
-    GenProgramPipelines = qopenglfResolveGenProgramPipelines;
-    IsProgramPipeline = qopenglfResolveIsProgramPipeline;
-    GetProgramPipelineiv = qopenglfResolveGetProgramPipelineiv;
-    ProgramUniform1i = qopenglfResolveProgramUniform1i;
-    ProgramUniform2i = qopenglfResolveProgramUniform2i;
-    ProgramUniform3i = qopenglfResolveProgramUniform3i;
-    ProgramUniform4i = qopenglfResolveProgramUniform4i;
-    ProgramUniform1ui = qopenglfResolveProgramUniform1ui;
-    ProgramUniform2ui = qopenglfResolveProgramUniform2ui;
-    ProgramUniform3ui = qopenglfResolveProgramUniform3ui;
-    ProgramUniform4ui = qopenglfResolveProgramUniform4ui;
-    ProgramUniform1f = qopenglfResolveProgramUniform1f;
-    ProgramUniform2f = qopenglfResolveProgramUniform2f;
-    ProgramUniform3f = qopenglfResolveProgramUniform3f;
-    ProgramUniform4f = qopenglfResolveProgramUniform4f;
-    ProgramUniform1iv = qopenglfResolveProgramUniform1iv;
-    ProgramUniform2iv = qopenglfResolveProgramUniform2iv;
-    ProgramUniform3iv = qopenglfResolveProgramUniform3iv;
-    ProgramUniform4iv = qopenglfResolveProgramUniform4iv;
-    ProgramUniform1uiv = qopenglfResolveProgramUniform1uiv;
-    ProgramUniform2uiv = qopenglfResolveProgramUniform2uiv;
-    ProgramUniform3uiv = qopenglfResolveProgramUniform3uiv;
-    ProgramUniform4uiv = qopenglfResolveProgramUniform4uiv;
-    ProgramUniform1fv = qopenglfResolveProgramUniform1fv;
-    ProgramUniform2fv = qopenglfResolveProgramUniform2fv;
-    ProgramUniform3fv = qopenglfResolveProgramUniform3fv;
-    ProgramUniform4fv = qopenglfResolveProgramUniform4fv;
-    ProgramUniformMatrix2fv = qopenglfResolveProgramUniformMatrix2fv;
-    ProgramUniformMatrix3fv = qopenglfResolveProgramUniformMatrix3fv;
-    ProgramUniformMatrix4fv = qopenglfResolveProgramUniformMatrix4fv;
-    ProgramUniformMatrix2x3fv = qopenglfResolveProgramUniformMatrix2x3fv;
-    ProgramUniformMatrix3x2fv = qopenglfResolveProgramUniformMatrix3x2fv;
-    ProgramUniformMatrix2x4fv = qopenglfResolveProgramUniformMatrix2x4fv;
-    ProgramUniformMatrix4x2fv = qopenglfResolveProgramUniformMatrix4x2fv;
-    ProgramUniformMatrix3x4fv = qopenglfResolveProgramUniformMatrix3x4fv;
-    ProgramUniformMatrix4x3fv = qopenglfResolveProgramUniformMatrix4x3fv;
-    ValidateProgramPipeline = qopenglfResolveValidateProgramPipeline;
-    GetProgramPipelineInfoLog = qopenglfResolveGetProgramPipelineInfoLog;
-    BindImageTexture = qopenglfResolveBindImageTexture;
-    GetBooleani_v = qopenglfResolveGetBooleani_v;
-    MemoryBarrierFunc = qopenglfResolveMemoryBarrier;
-    MemoryBarrierByRegion = qopenglfResolveMemoryBarrierByRegion;
-    TexStorage2DMultisample = qopenglfResolveTexStorage2DMultisample;
-    GetMultisamplefv = qopenglfResolveGetMultisamplefv;
-    SampleMaski = qopenglfResolveSampleMaski;
-    GetTexLevelParameteriv = qopenglfResolveGetTexLevelParameteriv;
-    GetTexLevelParameterfv = qopenglfResolveGetTexLevelParameterfv;
-    BindVertexBuffer = qopenglfResolveBindVertexBuffer;
-    VertexAttribFormat = qopenglfResolveVertexAttribFormat;
-    VertexAttribIFormat = qopenglfResolveVertexAttribIFormat;
-    VertexAttribBinding = qopenglfResolveVertexAttribBinding;
-    VertexBindingDivisor = qopenglfResolveVertexBindingDivisor;
+    init(ctx);
 }
 
+QT_OPENGL_IMPLEMENT(QOpenGLExtraFunctionsPrivate, QT_OPENGL_EXTRA_FUNCTIONS)
+
 QOpenGLExtensionsPrivate::QOpenGLExtensionsPrivate(QOpenGLContext *ctx)
     : QOpenGLExtraFunctionsPrivate(ctx),
       flushVendorChecked(false)
 {
-    MapBuffer = qopenglfResolveMapBuffer;
-    GetBufferSubData = qopenglfResolveGetBufferSubData;
-    DiscardFramebuffer = qopenglfResolveDiscardFramebuffer;
-}
+    QOpenGLContext *context = QOpenGLContext::currentContext();
 
-QOpenGLES3Helper *QOpenGLExtensions::gles3Helper()
-{
-    return qgles3Helper();
-}
+    MapBuffer = RESOLVE(MapBuffer);
+    GetBufferSubData = RESOLVE(GetBufferSubData);
+    DiscardFramebuffer = RESOLVE(DiscardFramebuffer);
+ }
 
 void QOpenGLExtensions::flushShared()
 {
diff --git a/src/gui/opengl/qopenglfunctions.h b/src/gui/opengl/qopenglfunctions.h
index ed42e59e5db..f6cd0e553ea 100644
--- a/src/gui/opengl/qopenglfunctions.h
+++ b/src/gui/opengl/qopenglfunctions.h
@@ -56,6 +56,10 @@
 
 //#define Q_ENABLE_OPENGL_FUNCTIONS_DEBUG
 
+#ifdef QT_OPENGL_ES
+typedef double GLdouble;
+#endif
+
 #ifdef Q_ENABLE_OPENGL_FUNCTIONS_DEBUG
 #include <stdio.h>
 #define Q_OPENGL_FUNCTIONS_DEBUG \
@@ -414,159 +418,173 @@ protected:
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(QOpenGLFunctions::OpenGLFeatures)
 
+#define QT_OPENGL_DECLARE_FUNCTIONS(ret, name, args) \
+    ret (QOPENGLF_APIENTRYP name)args;
+#define QT_OPENGL_COUNT_FUNCTIONS(ret, name, args) +1
+
+#define QT_OPENGL_DECLARE(FUNCTIONS) \
+public: \
+    struct Functions { \
+        FUNCTIONS(QT_OPENGL_DECLARE_FUNCTIONS) \
+    }; \
+    union { \
+        QFunctionPointer functions[FUNCTIONS(QT_OPENGL_COUNT_FUNCTIONS)]; \
+        Functions f; \
+    }; \
+private: \
+    void init(QOpenGLContext *context);
+
 struct QOpenGLFunctionsPrivate
 {
     QOpenGLFunctionsPrivate(QOpenGLContext *ctx);
 
-    void (QOPENGLF_APIENTRYP BindTexture)(GLenum target, GLuint texture);
-    void (QOPENGLF_APIENTRYP BlendFunc)(GLenum sfactor, GLenum dfactor);
-    void (QOPENGLF_APIENTRYP Clear)(GLbitfield mask);
-    void (QOPENGLF_APIENTRYP ClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-    void (QOPENGLF_APIENTRYP ClearDepthf)(GLclampf depth);
-    void (QOPENGLF_APIENTRYP ClearStencil)(GLint s);
-    void (QOPENGLF_APIENTRYP ColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void (QOPENGLF_APIENTRYP CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void (QOPENGLF_APIENTRYP CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP CullFace)(GLenum mode);
-    void (QOPENGLF_APIENTRYP DeleteTextures)(GLsizei n, const GLuint* textures);
-    void (QOPENGLF_APIENTRYP DepthFunc)(GLenum func);
-    void (QOPENGLF_APIENTRYP DepthMask)(GLboolean flag);
-    void (QOPENGLF_APIENTRYP DepthRangef)(GLclampf nearVal, GLclampf farVal);
-    void (QOPENGLF_APIENTRYP Disable)(GLenum cap);
-    void (QOPENGLF_APIENTRYP DrawArrays)(GLenum mode, GLint first, GLsizei count);
-    void (QOPENGLF_APIENTRYP DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices);
-    void (QOPENGLF_APIENTRYP Enable)(GLenum cap);
-    void (QOPENGLF_APIENTRYP Finish)();
-    void (QOPENGLF_APIENTRYP Flush)();
-    void (QOPENGLF_APIENTRYP FrontFace)(GLenum mode);
-    void (QOPENGLF_APIENTRYP GenTextures)(GLsizei n, GLuint* textures);
-    void (QOPENGLF_APIENTRYP GetBooleanv)(GLenum pname, GLboolean* params);
-    GLenum (QOPENGLF_APIENTRYP GetError)();
-    void (QOPENGLF_APIENTRYP GetFloatv)(GLenum pname, GLfloat* params);
-    void (QOPENGLF_APIENTRYP GetIntegerv)(GLenum pname, GLint* params);
-    const GLubyte * (QOPENGLF_APIENTRYP GetString)(GLenum name);
-    void (QOPENGLF_APIENTRYP GetTexParameterfv)(GLenum target, GLenum pname, GLfloat* params);
-    void (QOPENGLF_APIENTRYP GetTexParameteriv)(GLenum target, GLenum pname, GLint* params);
-    void (QOPENGLF_APIENTRYP Hint)(GLenum target, GLenum mode);
-    GLboolean (QOPENGLF_APIENTRYP IsEnabled)(GLenum cap);
-    GLboolean (QOPENGLF_APIENTRYP IsTexture)(GLuint texture);
-    void (QOPENGLF_APIENTRYP LineWidth)(GLfloat width);
-    void (QOPENGLF_APIENTRYP PixelStorei)(GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP PolygonOffset)(GLfloat factor, GLfloat units);
-    void (QOPENGLF_APIENTRYP ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);
-    void (QOPENGLF_APIENTRYP Scissor)(GLint x, GLint y, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP StencilFunc)(GLenum func, GLint ref, GLuint mask);
-    void (QOPENGLF_APIENTRYP StencilMask)(GLuint mask);
-    void (QOPENGLF_APIENTRYP StencilOp)(GLenum fail, GLenum zfail, GLenum zpass);
-    void (QOPENGLF_APIENTRYP TexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
-    void (QOPENGLF_APIENTRYP TexParameterf)(GLenum target, GLenum pname, GLfloat param);
-    void (QOPENGLF_APIENTRYP TexParameterfv)(GLenum target, GLenum pname, const GLfloat* params);
-    void (QOPENGLF_APIENTRYP TexParameteri)(GLenum target, GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP TexParameteriv)(GLenum target, GLenum pname, const GLint* params);
-    void (QOPENGLF_APIENTRYP TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels);
-    void (QOPENGLF_APIENTRYP Viewport)(GLint x, GLint y, GLsizei width, GLsizei height);
+#define QT_OPENGL_FUNCTIONS(F) \
+    F(void, BindTexture, (GLenum target, GLuint texture)) \
+    F(void, BlendFunc, (GLenum sfactor, GLenum dfactor)) \
+    F(void, Clear, (GLbitfield mask)) \
+    F(void, ClearColor, (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)) \
+    F(void, ClearDepthf, (GLclampf depth)) \
+    F(void, ClearStencil, (GLint s)) \
+    F(void, ColorMask, (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)) \
+    F(void, CopyTexImage2D, (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)) \
+    F(void, CopyTexSubImage2D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)) \
+    F(void, CullFace, (GLenum mode)) \
+    F(void, DeleteTextures, (GLsizei n, const GLuint* textures)) \
+    F(void, DepthFunc, (GLenum func)) \
+    F(void, DepthMask, (GLboolean flag)) \
+    F(void, DepthRangef, (GLclampf nearVal, GLclampf farVal)) \
+    F(void, Disable, (GLenum cap)) \
+    F(void, DrawArrays, (GLenum mode, GLint first, GLsizei count)) \
+    F(void, DrawElements, (GLenum mode, GLsizei count, GLenum type, const GLvoid* indices)) \
+    F(void, Enable, (GLenum cap)) \
+    F(void, Finish, ()) \
+    F(void, Flush, ()) \
+    F(void, FrontFace, (GLenum mode)) \
+    F(void, GenTextures, (GLsizei n, GLuint* textures)) \
+    F(void, GetBooleanv, (GLenum pname, GLboolean* params)) \
+    F(GLenum, GetError, ()) \
+    F(void, GetFloatv, (GLenum pname, GLfloat* params)) \
+    F(void, GetIntegerv, (GLenum pname, GLint* params)) \
+    F(const GLubyte *, GetString, (GLenum name)) \
+    F(void, GetTexParameterfv, (GLenum target, GLenum pname, GLfloat* params)) \
+    F(void, GetTexParameteriv, (GLenum target, GLenum pname, GLint* params)) \
+    F(void, Hint, (GLenum target, GLenum mode)) \
+    F(GLboolean, IsEnabled, (GLenum cap)) \
+    F(GLboolean, IsTexture, (GLuint texture)) \
+    F(void, LineWidth, (GLfloat width)) \
+    F(void, PixelStorei, (GLenum pname, GLint param)) \
+    F(void, PolygonOffset, (GLfloat factor, GLfloat units)) \
+    F(void, ReadPixels, (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels)) \
+    F(void, Scissor, (GLint x, GLint y, GLsizei width, GLsizei height)) \
+    F(void, StencilFunc, (GLenum func, GLint ref, GLuint mask)) \
+    F(void, StencilMask, (GLuint mask)) \
+    F(void, StencilOp, (GLenum fail, GLenum zfail, GLenum zpass)) \
+    F(void, TexImage2D, (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels)) \
+    F(void, TexParameterf, (GLenum target, GLenum pname, GLfloat param)) \
+    F(void, TexParameterfv, (GLenum target, GLenum pname, const GLfloat* params)) \
+    F(void, TexParameteri, (GLenum target, GLenum pname, GLint param)) \
+    F(void, TexParameteriv, (GLenum target, GLenum pname, const GLint* params)) \
+    F(void, TexSubImage2D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels)) \
+    F(void, Viewport, (GLint x, GLint y, GLsizei width, GLsizei height)) \
+    F(void, ActiveTexture, (GLenum texture)) \
+    F(void, AttachShader, (GLuint program, GLuint shader)) \
+    F(void, BindAttribLocation, (GLuint program, GLuint index, const char* name)) \
+    F(void, BindBuffer, (GLenum target, GLuint buffer)) \
+    F(void, BindFramebuffer, (GLenum target, GLuint framebuffer)) \
+    F(void, BindRenderbuffer, (GLenum target, GLuint renderbuffer)) \
+    F(void, BlendColor, (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)) \
+    F(void, BlendEquation, (GLenum mode)) \
+    F(void, BlendEquationSeparate, (GLenum modeRGB, GLenum modeAlpha)) \
+    F(void, BlendFuncSeparate, (GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)) \
+    F(void, BufferData, (GLenum target, qopengl_GLsizeiptr size, const void* data, GLenum usage)) \
+    F(void, BufferSubData, (GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, const void* data)) \
+    F(GLenum, CheckFramebufferStatus, (GLenum target)) \
+    F(void, CompileShader, (GLuint shader)) \
+    F(void, CompressedTexImage2D, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data)) \
+    F(void, CompressedTexSubImage2D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data)) \
+    F(GLuint, CreateProgram, ()) \
+    F(GLuint, CreateShader, (GLenum type)) \
+    F(void, DeleteBuffers, (GLsizei n, const GLuint* buffers)) \
+    F(void, DeleteFramebuffers, (GLsizei n, const GLuint* framebuffers)) \
+    F(void, DeleteProgram, (GLuint program)) \
+    F(void, DeleteRenderbuffers, (GLsizei n, const GLuint* renderbuffers)) \
+    F(void, DeleteShader, (GLuint shader)) \
+    F(void, DetachShader, (GLuint program, GLuint shader)) \
+    F(void, DisableVertexAttribArray, (GLuint index)) \
+    F(void, EnableVertexAttribArray, (GLuint index)) \
+    F(void, FramebufferRenderbuffer, (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)) \
+    F(void, FramebufferTexture2D, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)) \
+    F(void, GenBuffers, (GLsizei n, GLuint* buffers)) \
+    F(void, GenerateMipmap, (GLenum target)) \
+    F(void, GenFramebuffers, (GLsizei n, GLuint* framebuffers)) \
+    F(void, GenRenderbuffers, (GLsizei n, GLuint* renderbuffers)) \
+    F(void, GetActiveAttrib, (GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)) \
+    F(void, GetActiveUniform, (GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name)) \
+    F(void, GetAttachedShaders, (GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders)) \
+    F(GLint, GetAttribLocation, (GLuint program, const char* name)) \
+    F(void, GetBufferParameteriv, (GLenum target, GLenum pname, GLint* params)) \
+    F(void, GetFramebufferAttachmentParameteriv, (GLenum target, GLenum attachment, GLenum pname, GLint* params)) \
+    F(void, GetProgramiv, (GLuint program, GLenum pname, GLint* params)) \
+    F(void, GetProgramInfoLog, (GLuint program, GLsizei bufsize, GLsizei* length, char* infolog)) \
+    F(void, GetRenderbufferParameteriv, (GLenum target, GLenum pname, GLint* params)) \
+    F(void, GetShaderiv, (GLuint shader, GLenum pname, GLint* params)) \
+    F(void, GetShaderInfoLog, (GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog)) \
+    F(void, GetShaderPrecisionFormat, (GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision)) \
+    F(void, GetShaderSource, (GLuint shader, GLsizei bufsize, GLsizei* length, char* source)) \
+    F(void, GetUniformfv, (GLuint program, GLint location, GLfloat* params)) \
+    F(void, GetUniformiv, (GLuint program, GLint location, GLint* params)) \
+    F(GLint, GetUniformLocation, (GLuint program, const char* name)) \
+    F(void, GetVertexAttribfv, (GLuint index, GLenum pname, GLfloat* params)) \
+    F(void, GetVertexAttribiv, (GLuint index, GLenum pname, GLint* params)) \
+    F(void, GetVertexAttribPointerv, (GLuint index, GLenum pname, void** pointer)) \
+    F(GLboolean, IsBuffer, (GLuint buffer)) \
+    F(GLboolean, IsFramebuffer, (GLuint framebuffer)) \
+    F(GLboolean, IsProgram, (GLuint program)) \
+    F(GLboolean, IsRenderbuffer, (GLuint renderbuffer)) \
+    F(GLboolean, IsShader, (GLuint shader)) \
+    F(void, LinkProgram, (GLuint program)) \
+    F(void, ReleaseShaderCompiler, ()) \
+    F(void, RenderbufferStorage, (GLenum target, GLenum internalformat, GLsizei width, GLsizei height)) \
+    F(void, SampleCoverage, (GLclampf value, GLboolean invert)) \
+    F(void, ShaderBinary, (GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length)) \
+    F(void, ShaderSource, (GLuint shader, GLsizei count, const char** string, const GLint* length)) \
+    F(void, StencilFuncSeparate, (GLenum face, GLenum func, GLint ref, GLuint mask)) \
+    F(void, StencilMaskSeparate, (GLenum face, GLuint mask)) \
+    F(void, StencilOpSeparate, (GLenum face, GLenum fail, GLenum zfail, GLenum zpass)) \
+    F(void, Uniform1f, (GLint location, GLfloat x)) \
+    F(void, Uniform1fv, (GLint location, GLsizei count, const GLfloat* v)) \
+    F(void, Uniform1i, (GLint location, GLint x)) \
+    F(void, Uniform1iv, (GLint location, GLsizei count, const GLint* v)) \
+    F(void, Uniform2f, (GLint location, GLfloat x, GLfloat y)) \
+    F(void, Uniform2fv, (GLint location, GLsizei count, const GLfloat* v)) \
+    F(void, Uniform2i, (GLint location, GLint x, GLint y)) \
+    F(void, Uniform2iv, (GLint location, GLsizei count, const GLint* v)) \
+    F(void, Uniform3f, (GLint location, GLfloat x, GLfloat y, GLfloat z)) \
+    F(void, Uniform3fv, (GLint location, GLsizei count, const GLfloat* v)) \
+    F(void, Uniform3i, (GLint location, GLint x, GLint y, GLint z)) \
+    F(void, Uniform3iv, (GLint location, GLsizei count, const GLint* v)) \
+    F(void, Uniform4f, (GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
+    F(void, Uniform4fv, (GLint location, GLsizei count, const GLfloat* v)) \
+    F(void, Uniform4i, (GLint location, GLint x, GLint y, GLint z, GLint w)) \
+    F(void, Uniform4iv, (GLint location, GLsizei count, const GLint* v)) \
+    F(void, UniformMatrix2fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)) \
+    F(void, UniformMatrix3fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)) \
+    F(void, UniformMatrix4fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat* value)) \
+    F(void, UseProgram, (GLuint program)) \
+    F(void, ValidateProgram, (GLuint program)) \
+    F(void, VertexAttrib1f, (GLuint indx, GLfloat x)) \
+    F(void, VertexAttrib1fv, (GLuint indx, const GLfloat* values)) \
+    F(void, VertexAttrib2f, (GLuint indx, GLfloat x, GLfloat y)) \
+    F(void, VertexAttrib2fv, (GLuint indx, const GLfloat* values)) \
+    F(void, VertexAttrib3f, (GLuint indx, GLfloat x, GLfloat y, GLfloat z)) \
+    F(void, VertexAttrib3fv, (GLuint indx, const GLfloat* values)) \
+    F(void, VertexAttrib4f, (GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
+    F(void, VertexAttrib4fv, (GLuint indx, const GLfloat* values)) \
+    F(void, VertexAttribPointer, (GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr)) \
+    F(void, ClearDepth, (GLdouble depth)) \
+    F(void, DepthRange, (GLdouble zNear, GLdouble zFar)) \
 
-    void (QOPENGLF_APIENTRYP ActiveTexture)(GLenum texture);
-    void (QOPENGLF_APIENTRYP AttachShader)(GLuint program, GLuint shader);
-    void (QOPENGLF_APIENTRYP BindAttribLocation)(GLuint program, GLuint index, const char* name);
-    void (QOPENGLF_APIENTRYP BindBuffer)(GLenum target, GLuint buffer);
-    void (QOPENGLF_APIENTRYP BindFramebuffer)(GLenum target, GLuint framebuffer);
-    void (QOPENGLF_APIENTRYP BindRenderbuffer)(GLenum target, GLuint renderbuffer);
-    void (QOPENGLF_APIENTRYP BlendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-    void (QOPENGLF_APIENTRYP BlendEquation)(GLenum mode);
-    void (QOPENGLF_APIENTRYP BlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha);
-    void (QOPENGLF_APIENTRYP BlendFuncSeparate)(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void (QOPENGLF_APIENTRYP BufferData)(GLenum target, qopengl_GLsizeiptr size, const void* data, GLenum usage);
-    void (QOPENGLF_APIENTRYP BufferSubData)(GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, const void* data);
-    GLenum (QOPENGLF_APIENTRYP CheckFramebufferStatus)(GLenum target);
-    void (QOPENGLF_APIENTRYP CompileShader)(GLuint shader);
-    void (QOPENGLF_APIENTRYP CompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data);
-    void (QOPENGLF_APIENTRYP CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data);
-    GLuint (QOPENGLF_APIENTRYP CreateProgram)();
-    GLuint (QOPENGLF_APIENTRYP CreateShader)(GLenum type);
-    void (QOPENGLF_APIENTRYP DeleteBuffers)(GLsizei n, const GLuint* buffers);
-    void (QOPENGLF_APIENTRYP DeleteFramebuffers)(GLsizei n, const GLuint* framebuffers);
-    void (QOPENGLF_APIENTRYP DeleteProgram)(GLuint program);
-    void (QOPENGLF_APIENTRYP DeleteRenderbuffers)(GLsizei n, const GLuint* renderbuffers);
-    void (QOPENGLF_APIENTRYP DeleteShader)(GLuint shader);
-    void (QOPENGLF_APIENTRYP DetachShader)(GLuint program, GLuint shader);
-    void (QOPENGLF_APIENTRYP DisableVertexAttribArray)(GLuint index);
-    void (QOPENGLF_APIENTRYP EnableVertexAttribArray)(GLuint index);
-    void (QOPENGLF_APIENTRYP FramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void (QOPENGLF_APIENTRYP FramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void (QOPENGLF_APIENTRYP GenBuffers)(GLsizei n, GLuint* buffers);
-    void (QOPENGLF_APIENTRYP GenerateMipmap)(GLenum target);
-    void (QOPENGLF_APIENTRYP GenFramebuffers)(GLsizei n, GLuint* framebuffers);
-    void (QOPENGLF_APIENTRYP GenRenderbuffers)(GLsizei n, GLuint* renderbuffers);
-    void (QOPENGLF_APIENTRYP GetActiveAttrib)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
-    void (QOPENGLF_APIENTRYP GetActiveUniform)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
-    void (QOPENGLF_APIENTRYP GetAttachedShaders)(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);
-    GLint (QOPENGLF_APIENTRYP GetAttribLocation)(GLuint program, const char* name);
-    void (QOPENGLF_APIENTRYP GetBufferParameteriv)(GLenum target, GLenum pname, GLint* params);
-    void (QOPENGLF_APIENTRYP GetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint* params);
-    void (QOPENGLF_APIENTRYP GetProgramiv)(GLuint program, GLenum pname, GLint* params);
-    void (QOPENGLF_APIENTRYP GetProgramInfoLog)(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog);
-    void (QOPENGLF_APIENTRYP GetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint* params);
-    void (QOPENGLF_APIENTRYP GetShaderiv)(GLuint shader, GLenum pname, GLint* params);
-    void (QOPENGLF_APIENTRYP GetShaderInfoLog)(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog);
-    void (QOPENGLF_APIENTRYP GetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
-    void (QOPENGLF_APIENTRYP GetShaderSource)(GLuint shader, GLsizei bufsize, GLsizei* length, char* source);
-    void (QOPENGLF_APIENTRYP GetUniformfv)(GLuint program, GLint location, GLfloat* params);
-    void (QOPENGLF_APIENTRYP GetUniformiv)(GLuint program, GLint location, GLint* params);
-    GLint (QOPENGLF_APIENTRYP GetUniformLocation)(GLuint program, const char* name);
-    void (QOPENGLF_APIENTRYP GetVertexAttribfv)(GLuint index, GLenum pname, GLfloat* params);
-    void (QOPENGLF_APIENTRYP GetVertexAttribiv)(GLuint index, GLenum pname, GLint* params);
-    void (QOPENGLF_APIENTRYP GetVertexAttribPointerv)(GLuint index, GLenum pname, void** pointer);
-    GLboolean (QOPENGLF_APIENTRYP IsBuffer)(GLuint buffer);
-    GLboolean (QOPENGLF_APIENTRYP IsFramebuffer)(GLuint framebuffer);
-    GLboolean (QOPENGLF_APIENTRYP IsProgram)(GLuint program);
-    GLboolean (QOPENGLF_APIENTRYP IsRenderbuffer)(GLuint renderbuffer);
-    GLboolean (QOPENGLF_APIENTRYP IsShader)(GLuint shader);
-    void (QOPENGLF_APIENTRYP LinkProgram)(GLuint program);
-    void (QOPENGLF_APIENTRYP ReleaseShaderCompiler)();
-    void (QOPENGLF_APIENTRYP RenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP SampleCoverage)(GLclampf value, GLboolean invert);
-    void (QOPENGLF_APIENTRYP ShaderBinary)(GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length);
-    void (QOPENGLF_APIENTRYP ShaderSource)(GLuint shader, GLsizei count, const char** string, const GLint* length);
-    void (QOPENGLF_APIENTRYP StencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void (QOPENGLF_APIENTRYP StencilMaskSeparate)(GLenum face, GLuint mask);
-    void (QOPENGLF_APIENTRYP StencilOpSeparate)(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
-    void (QOPENGLF_APIENTRYP Uniform1f)(GLint location, GLfloat x);
-    void (QOPENGLF_APIENTRYP Uniform1fv)(GLint location, GLsizei count, const GLfloat* v);
-    void (QOPENGLF_APIENTRYP Uniform1i)(GLint location, GLint x);
-    void (QOPENGLF_APIENTRYP Uniform1iv)(GLint location, GLsizei count, const GLint* v);
-    void (QOPENGLF_APIENTRYP Uniform2f)(GLint location, GLfloat x, GLfloat y);
-    void (QOPENGLF_APIENTRYP Uniform2fv)(GLint location, GLsizei count, const GLfloat* v);
-    void (QOPENGLF_APIENTRYP Uniform2i)(GLint location, GLint x, GLint y);
-    void (QOPENGLF_APIENTRYP Uniform2iv)(GLint location, GLsizei count, const GLint* v);
-    void (QOPENGLF_APIENTRYP Uniform3f)(GLint location, GLfloat x, GLfloat y, GLfloat z);
-    void (QOPENGLF_APIENTRYP Uniform3fv)(GLint location, GLsizei count, const GLfloat* v);
-    void (QOPENGLF_APIENTRYP Uniform3i)(GLint location, GLint x, GLint y, GLint z);
-    void (QOPENGLF_APIENTRYP Uniform3iv)(GLint location, GLsizei count, const GLint* v);
-    void (QOPENGLF_APIENTRYP Uniform4f)(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void (QOPENGLF_APIENTRYP Uniform4fv)(GLint location, GLsizei count, const GLfloat* v);
-    void (QOPENGLF_APIENTRYP Uniform4i)(GLint location, GLint x, GLint y, GLint z, GLint w);
-    void (QOPENGLF_APIENTRYP Uniform4iv)(GLint location, GLsizei count, const GLint* v);
-    void (QOPENGLF_APIENTRYP UniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-    void (QOPENGLF_APIENTRYP UniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-    void (QOPENGLF_APIENTRYP UniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-    void (QOPENGLF_APIENTRYP UseProgram)(GLuint program);
-    void (QOPENGLF_APIENTRYP ValidateProgram)(GLuint program);
-    void (QOPENGLF_APIENTRYP VertexAttrib1f)(GLuint indx, GLfloat x);
-    void (QOPENGLF_APIENTRYP VertexAttrib1fv)(GLuint indx, const GLfloat* values);
-    void (QOPENGLF_APIENTRYP VertexAttrib2f)(GLuint indx, GLfloat x, GLfloat y);
-    void (QOPENGLF_APIENTRYP VertexAttrib2fv)(GLuint indx, const GLfloat* values);
-    void (QOPENGLF_APIENTRYP VertexAttrib3f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z);
-    void (QOPENGLF_APIENTRYP VertexAttrib3fv)(GLuint indx, const GLfloat* values);
-    void (QOPENGLF_APIENTRYP VertexAttrib4f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void (QOPENGLF_APIENTRYP VertexAttrib4fv)(GLuint indx, const GLfloat* values);
-    void (QOPENGLF_APIENTRYP VertexAttribPointer)(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr);
-
-    // Special non-ES OpenGL variants, not to be called directly
-#ifndef QT_OPENGL_ES_2
-    void (QOPENGLF_APIENTRYP ClearDepth)(GLdouble depth);
-    void (QOPENGLF_APIENTRYP DepthRange)(GLdouble zNear, GLdouble zFar);
-#endif
+    QT_OPENGL_DECLARE(QT_OPENGL_FUNCTIONS)
 };
 
 // GLES2 + OpenGL1 common subset
@@ -577,7 +595,7 @@ inline void QOpenGLFunctions::glBindTexture(GLenum target, GLuint texture)
     ::glBindTexture(target, texture);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->BindTexture(target, texture);
+    d_ptr->f.BindTexture(target, texture);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -588,7 +606,7 @@ inline void QOpenGLFunctions::glBlendFunc(GLenum sfactor, GLenum dfactor)
     ::glBlendFunc(sfactor, dfactor);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->BlendFunc(sfactor, dfactor);
+    d_ptr->f.BlendFunc(sfactor, dfactor);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -599,7 +617,7 @@ inline void QOpenGLFunctions::glClear(GLbitfield mask)
     ::glClear(mask);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Clear(mask);
+    d_ptr->f.Clear(mask);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -610,7 +628,7 @@ inline void QOpenGLFunctions::glClearColor(GLclampf red, GLclampf green, GLclamp
     ::glClearColor(red, green, blue, alpha);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->ClearColor(red, green, blue, alpha);
+    d_ptr->f.ClearColor(red, green, blue, alpha);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -621,7 +639,7 @@ inline void QOpenGLFunctions::glClearStencil(GLint s)
     ::glClearStencil(s);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->ClearStencil(s);
+    d_ptr->f.ClearStencil(s);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -632,7 +650,7 @@ inline void QOpenGLFunctions::glColorMask(GLboolean red, GLboolean green, GLbool
     ::glColorMask(red, green, blue, alpha);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->ColorMask(red, green, blue, alpha);
+    d_ptr->f.ColorMask(red, green, blue, alpha);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -643,7 +661,7 @@ inline void QOpenGLFunctions::glCopyTexImage2D(GLenum target, GLint level, GLenu
     ::glCopyTexImage2D(target, level, internalformat, x, y, width,height, border);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->CopyTexImage2D(target, level, internalformat, x, y, width,height, border);
+    d_ptr->f.CopyTexImage2D(target, level, internalformat, x, y, width,height, border);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -654,7 +672,7 @@ inline void QOpenGLFunctions::glCopyTexSubImage2D(GLenum target, GLint level, GL
     ::glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_ptr->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -665,7 +683,7 @@ inline void QOpenGLFunctions::glCullFace(GLenum mode)
     ::glCullFace(mode);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->CullFace(mode);
+    d_ptr->f.CullFace(mode);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -676,7 +694,7 @@ inline void QOpenGLFunctions::glDeleteTextures(GLsizei n, const GLuint* textures
     ::glDeleteTextures(n, textures);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->DeleteTextures(n, textures);
+    d_ptr->f.DeleteTextures(n, textures);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -687,7 +705,7 @@ inline void QOpenGLFunctions::glDepthFunc(GLenum func)
     ::glDepthFunc(func);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->DepthFunc(func);
+    d_ptr->f.DepthFunc(func);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -698,7 +716,7 @@ inline void QOpenGLFunctions::glDepthMask(GLboolean flag)
     ::glDepthMask(flag);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->DepthMask(flag);
+    d_ptr->f.DepthMask(flag);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -709,7 +727,7 @@ inline void QOpenGLFunctions::glDisable(GLenum cap)
     ::glDisable(cap);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Disable(cap);
+    d_ptr->f.Disable(cap);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -720,7 +738,7 @@ inline void QOpenGLFunctions::glDrawArrays(GLenum mode, GLint first, GLsizei cou
     ::glDrawArrays(mode, first, count);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->DrawArrays(mode, first, count);
+    d_ptr->f.DrawArrays(mode, first, count);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -731,7 +749,7 @@ inline void QOpenGLFunctions::glDrawElements(GLenum mode, GLsizei count, GLenum
     ::glDrawElements(mode, count, type, indices);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->DrawElements(mode, count, type, indices);
+    d_ptr->f.DrawElements(mode, count, type, indices);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -742,7 +760,7 @@ inline void QOpenGLFunctions::glEnable(GLenum cap)
     ::glEnable(cap);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Enable(cap);
+    d_ptr->f.Enable(cap);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -753,7 +771,7 @@ inline void QOpenGLFunctions::glFinish()
     ::glFinish();
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Finish();
+    d_ptr->f.Finish();
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -764,7 +782,7 @@ inline void QOpenGLFunctions::glFlush()
     ::glFlush();
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Flush();
+    d_ptr->f.Flush();
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -775,7 +793,7 @@ inline void QOpenGLFunctions::glFrontFace(GLenum mode)
     ::glFrontFace(mode);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->FrontFace(mode);
+    d_ptr->f.FrontFace(mode);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -786,7 +804,7 @@ inline void QOpenGLFunctions::glGenTextures(GLsizei n, GLuint* textures)
     ::glGenTextures(n, textures);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GenTextures(n, textures);
+    d_ptr->f.GenTextures(n, textures);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -797,7 +815,7 @@ inline void QOpenGLFunctions::glGetBooleanv(GLenum pname, GLboolean* params)
     ::glGetBooleanv(pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetBooleanv(pname, params);
+    d_ptr->f.GetBooleanv(pname, params);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -808,7 +826,7 @@ inline GLenum QOpenGLFunctions::glGetError()
     GLenum result = ::glGetError();
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    GLenum result = d_ptr->GetError();
+    GLenum result = d_ptr->f.GetError();
 #endif
     return result;
 }
@@ -819,7 +837,7 @@ inline void QOpenGLFunctions::glGetFloatv(GLenum pname, GLfloat* params)
     ::glGetFloatv(pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetFloatv(pname, params);
+    d_ptr->f.GetFloatv(pname, params);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -830,7 +848,7 @@ inline void QOpenGLFunctions::glGetIntegerv(GLenum pname, GLint* params)
     ::glGetIntegerv(pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetIntegerv(pname, params);
+    d_ptr->f.GetIntegerv(pname, params);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -841,7 +859,7 @@ inline const GLubyte *QOpenGLFunctions::glGetString(GLenum name)
     const GLubyte *result = ::glGetString(name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    const GLubyte *result = d_ptr->GetString(name);
+    const GLubyte *result = d_ptr->f.GetString(name);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
@@ -853,7 +871,7 @@ inline void QOpenGLFunctions::glGetTexParameterfv(GLenum target, GLenum pname, G
     ::glGetTexParameterfv(target, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetTexParameterfv(target, pname, params);
+    d_ptr->f.GetTexParameterfv(target, pname, params);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -864,7 +882,7 @@ inline void QOpenGLFunctions::glGetTexParameteriv(GLenum target, GLenum pname, G
     ::glGetTexParameteriv(target, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetTexParameteriv(target, pname, params);
+    d_ptr->f.GetTexParameteriv(target, pname, params);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -875,7 +893,7 @@ inline void QOpenGLFunctions::glHint(GLenum target, GLenum mode)
     ::glHint(target, mode);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Hint(target, mode);
+    d_ptr->f.Hint(target, mode);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -886,7 +904,7 @@ inline GLboolean QOpenGLFunctions::glIsEnabled(GLenum cap)
     GLboolean result = ::glIsEnabled(cap);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    GLboolean result = d_ptr->IsEnabled(cap);
+    GLboolean result = d_ptr->f.IsEnabled(cap);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
@@ -898,7 +916,7 @@ inline GLboolean QOpenGLFunctions::glIsTexture(GLuint texture)
     GLboolean result = ::glIsTexture(texture);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    GLboolean result = d_ptr->IsTexture(texture);
+    GLboolean result = d_ptr->f.IsTexture(texture);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
@@ -910,7 +928,7 @@ inline void QOpenGLFunctions::glLineWidth(GLfloat width)
     ::glLineWidth(width);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->LineWidth(width);
+    d_ptr->f.LineWidth(width);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -921,7 +939,7 @@ inline void QOpenGLFunctions::glPixelStorei(GLenum pname, GLint param)
     ::glPixelStorei(pname, param);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->PixelStorei(pname, param);
+    d_ptr->f.PixelStorei(pname, param);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -932,7 +950,7 @@ inline void QOpenGLFunctions::glPolygonOffset(GLfloat factor, GLfloat units)
     ::glPolygonOffset(factor, units);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->PolygonOffset(factor, units);
+    d_ptr->f.PolygonOffset(factor, units);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -943,7 +961,7 @@ inline void QOpenGLFunctions::glReadPixels(GLint x, GLint y, GLsizei width, GLsi
     ::glReadPixels(x, y, width, height, format, type, pixels);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->ReadPixels(x, y, width, height, format, type, pixels);
+    d_ptr->f.ReadPixels(x, y, width, height, format, type, pixels);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -954,7 +972,7 @@ inline void QOpenGLFunctions::glScissor(GLint x, GLint y, GLsizei width, GLsizei
     ::glScissor(x, y, width, height);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Scissor(x, y, width, height);
+    d_ptr->f.Scissor(x, y, width, height);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -965,7 +983,7 @@ inline void QOpenGLFunctions::glStencilFunc(GLenum func, GLint ref, GLuint mask)
     ::glStencilFunc(func, ref, mask);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->StencilFunc(func, ref, mask);
+    d_ptr->f.StencilFunc(func, ref, mask);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -976,7 +994,7 @@ inline void QOpenGLFunctions::glStencilMask(GLuint mask)
     ::glStencilMask(mask);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->StencilMask(mask);
+    d_ptr->f.StencilMask(mask);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -987,7 +1005,7 @@ inline void QOpenGLFunctions::glStencilOp(GLenum fail, GLenum zfail, GLenum zpas
     ::glStencilOp(fail, zfail, zpass);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->StencilOp(fail, zfail, zpass);
+    d_ptr->f.StencilOp(fail, zfail, zpass);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -998,7 +1016,7 @@ inline void QOpenGLFunctions::glTexImage2D(GLenum target, GLint level, GLint int
     ::glTexImage2D(target, level, internalformat, width,height, border, format, type, pixels);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->TexImage2D(target, level, internalformat, width,height, border, format, type, pixels);
+    d_ptr->f.TexImage2D(target, level, internalformat, width,height, border, format, type, pixels);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1009,7 +1027,7 @@ inline void QOpenGLFunctions::glTexParameterf(GLenum target, GLenum pname, GLflo
     ::glTexParameterf(target, pname, param);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->TexParameterf(target, pname, param);
+    d_ptr->f.TexParameterf(target, pname, param);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1020,7 +1038,7 @@ inline void QOpenGLFunctions::glTexParameterfv(GLenum target, GLenum pname, cons
     ::glTexParameterfv(target, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->TexParameterfv(target, pname, params);
+    d_ptr->f.TexParameterfv(target, pname, params);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1031,7 +1049,7 @@ inline void QOpenGLFunctions::glTexParameteri(GLenum target, GLenum pname, GLint
     ::glTexParameteri(target, pname, param);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->TexParameteri(target, pname, param);
+    d_ptr->f.TexParameteri(target, pname, param);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1042,7 +1060,7 @@ inline void QOpenGLFunctions::glTexParameteriv(GLenum target, GLenum pname, cons
     ::glTexParameteriv(target, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->TexParameteriv(target, pname, params);
+    d_ptr->f.TexParameteriv(target, pname, params);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1053,7 +1071,7 @@ inline void QOpenGLFunctions::glTexSubImage2D(GLenum target, GLint level, GLint
     ::glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_ptr->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1064,7 +1082,7 @@ inline void QOpenGLFunctions::glViewport(GLint x, GLint y, GLsizei width, GLsize
     ::glViewport(x, y, width, height);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Viewport(x, y, width, height);
+    d_ptr->f.Viewport(x, y, width, height);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1077,7 +1095,7 @@ inline void QOpenGLFunctions::glActiveTexture(GLenum texture)
     ::glActiveTexture(texture);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->ActiveTexture(texture);
+    d_ptr->f.ActiveTexture(texture);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1088,7 +1106,7 @@ inline void QOpenGLFunctions::glAttachShader(GLuint program, GLuint shader)
     ::glAttachShader(program, shader);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->AttachShader(program, shader);
+    d_ptr->f.AttachShader(program, shader);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1099,7 +1117,7 @@ inline void QOpenGLFunctions::glBindAttribLocation(GLuint program, GLuint index,
     ::glBindAttribLocation(program, index, name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->BindAttribLocation(program, index, name);
+    d_ptr->f.BindAttribLocation(program, index, name);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1110,7 +1128,7 @@ inline void QOpenGLFunctions::glBindBuffer(GLenum target, GLuint buffer)
     ::glBindBuffer(target, buffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->BindBuffer(target, buffer);
+    d_ptr->f.BindBuffer(target, buffer);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1123,7 +1141,7 @@ inline void QOpenGLFunctions::glBindFramebuffer(GLenum target, GLuint framebuffe
     ::glBindFramebuffer(target, framebuffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->BindFramebuffer(target, framebuffer);
+    d_ptr->f.BindFramebuffer(target, framebuffer);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1134,7 +1152,7 @@ inline void QOpenGLFunctions::glBindRenderbuffer(GLenum target, GLuint renderbuf
     ::glBindRenderbuffer(target, renderbuffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->BindRenderbuffer(target, renderbuffer);
+    d_ptr->f.BindRenderbuffer(target, renderbuffer);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1145,7 +1163,7 @@ inline void QOpenGLFunctions::glBlendColor(GLclampf red, GLclampf green, GLclamp
     ::glBlendColor(red, green, blue, alpha);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->BlendColor(red, green, blue, alpha);
+    d_ptr->f.BlendColor(red, green, blue, alpha);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1156,7 +1174,7 @@ inline void QOpenGLFunctions::glBlendEquation(GLenum mode)
     ::glBlendEquation(mode);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->BlendEquation(mode);
+    d_ptr->f.BlendEquation(mode);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1167,7 +1185,7 @@ inline void QOpenGLFunctions::glBlendEquationSeparate(GLenum modeRGB, GLenum mod
     ::glBlendEquationSeparate(modeRGB, modeAlpha);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_ptr->f.BlendEquationSeparate(modeRGB, modeAlpha);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1178,7 +1196,7 @@ inline void QOpenGLFunctions::glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB,
     ::glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
+    d_ptr->f.BlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1189,7 +1207,7 @@ inline void QOpenGLFunctions::glBufferData(GLenum target, qopengl_GLsizeiptr siz
     ::glBufferData(target, size, data, usage);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->BufferData(target, size, data, usage);
+    d_ptr->f.BufferData(target, size, data, usage);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1200,7 +1218,7 @@ inline void QOpenGLFunctions::glBufferSubData(GLenum target, qopengl_GLintptr of
     ::glBufferSubData(target, offset, size, data);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->BufferSubData(target, offset, size, data);
+    d_ptr->f.BufferSubData(target, offset, size, data);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1211,7 +1229,7 @@ inline GLenum QOpenGLFunctions::glCheckFramebufferStatus(GLenum target)
     GLenum result = ::glCheckFramebufferStatus(target);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    GLenum result = d_ptr->CheckFramebufferStatus(target);
+    GLenum result = d_ptr->f.CheckFramebufferStatus(target);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
@@ -1221,7 +1239,7 @@ inline void QOpenGLFunctions::glClearDepthf(GLclampf depth)
 {
 #ifndef QT_OPENGL_ES
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->ClearDepthf(depth);
+    d_ptr->f.ClearDepthf(depth);
 #else
     ::glClearDepthf(depth);
 #endif
@@ -1234,7 +1252,7 @@ inline void QOpenGLFunctions::glCompileShader(GLuint shader)
     ::glCompileShader(shader);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->CompileShader(shader);
+    d_ptr->f.CompileShader(shader);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1245,7 +1263,7 @@ inline void QOpenGLFunctions::glCompressedTexImage2D(GLenum target, GLint level,
     ::glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_ptr->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1256,7 +1274,7 @@ inline void QOpenGLFunctions::glCompressedTexSubImage2D(GLenum target, GLint lev
     ::glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_ptr->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1267,7 +1285,7 @@ inline GLuint QOpenGLFunctions::glCreateProgram()
     GLuint result = ::glCreateProgram();
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    GLuint result = d_ptr->CreateProgram();
+    GLuint result = d_ptr->f.CreateProgram();
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
@@ -1279,7 +1297,7 @@ inline GLuint QOpenGLFunctions::glCreateShader(GLenum type)
     GLuint result = ::glCreateShader(type);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    GLuint result = d_ptr->CreateShader(type);
+    GLuint result = d_ptr->f.CreateShader(type);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
@@ -1291,7 +1309,7 @@ inline void QOpenGLFunctions::glDeleteBuffers(GLsizei n, const GLuint* buffers)
     ::glDeleteBuffers(n, buffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->DeleteBuffers(n, buffers);
+    d_ptr->f.DeleteBuffers(n, buffers);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1302,7 +1320,7 @@ inline void QOpenGLFunctions::glDeleteFramebuffers(GLsizei n, const GLuint* fram
     ::glDeleteFramebuffers(n, framebuffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->DeleteFramebuffers(n, framebuffers);
+    d_ptr->f.DeleteFramebuffers(n, framebuffers);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1313,7 +1331,7 @@ inline void QOpenGLFunctions::glDeleteProgram(GLuint program)
     ::glDeleteProgram(program);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->DeleteProgram(program);
+    d_ptr->f.DeleteProgram(program);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1324,7 +1342,7 @@ inline void QOpenGLFunctions::glDeleteRenderbuffers(GLsizei n, const GLuint* ren
     ::glDeleteRenderbuffers(n, renderbuffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->DeleteRenderbuffers(n, renderbuffers);
+    d_ptr->f.DeleteRenderbuffers(n, renderbuffers);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1335,7 +1353,7 @@ inline void QOpenGLFunctions::glDeleteShader(GLuint shader)
     ::glDeleteShader(shader);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->DeleteShader(shader);
+    d_ptr->f.DeleteShader(shader);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1344,7 +1362,7 @@ inline void QOpenGLFunctions::glDepthRangef(GLclampf zNear, GLclampf zFar)
 {
 #ifndef QT_OPENGL_ES
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->DepthRangef(zNear, zFar);
+    d_ptr->f.DepthRangef(zNear, zFar);
 #else
     ::glDepthRangef(zNear, zFar);
 #endif
@@ -1357,7 +1375,7 @@ inline void QOpenGLFunctions::glDetachShader(GLuint program, GLuint shader)
     ::glDetachShader(program, shader);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->DetachShader(program, shader);
+    d_ptr->f.DetachShader(program, shader);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1368,7 +1386,7 @@ inline void QOpenGLFunctions::glDisableVertexAttribArray(GLuint index)
     ::glDisableVertexAttribArray(index);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->DisableVertexAttribArray(index);
+    d_ptr->f.DisableVertexAttribArray(index);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1379,7 +1397,7 @@ inline void QOpenGLFunctions::glEnableVertexAttribArray(GLuint index)
     ::glEnableVertexAttribArray(index);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->EnableVertexAttribArray(index);
+    d_ptr->f.EnableVertexAttribArray(index);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1390,7 +1408,7 @@ inline void QOpenGLFunctions::glFramebufferRenderbuffer(GLenum target, GLenum at
     ::glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_ptr->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1401,7 +1419,7 @@ inline void QOpenGLFunctions::glFramebufferTexture2D(GLenum target, GLenum attac
     ::glFramebufferTexture2D(target, attachment, textarget, texture, level);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_ptr->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1412,7 +1430,7 @@ inline void QOpenGLFunctions::glGenBuffers(GLsizei n, GLuint* buffers)
     ::glGenBuffers(n, buffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GenBuffers(n, buffers);
+    d_ptr->f.GenBuffers(n, buffers);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1423,7 +1441,7 @@ inline void QOpenGLFunctions::glGenerateMipmap(GLenum target)
     ::glGenerateMipmap(target);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GenerateMipmap(target);
+    d_ptr->f.GenerateMipmap(target);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1434,7 +1452,7 @@ inline void QOpenGLFunctions::glGenFramebuffers(GLsizei n, GLuint* framebuffers)
     ::glGenFramebuffers(n, framebuffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GenFramebuffers(n, framebuffers);
+    d_ptr->f.GenFramebuffers(n, framebuffers);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1445,7 +1463,7 @@ inline void QOpenGLFunctions::glGenRenderbuffers(GLsizei n, GLuint* renderbuffer
     ::glGenRenderbuffers(n, renderbuffers);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GenRenderbuffers(n, renderbuffers);
+    d_ptr->f.GenRenderbuffers(n, renderbuffers);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1456,7 +1474,7 @@ inline void QOpenGLFunctions::glGetActiveAttrib(GLuint program, GLuint index, GL
     ::glGetActiveAttrib(program, index, bufsize, length, size, type, name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetActiveAttrib(program, index, bufsize, length, size, type, name);
+    d_ptr->f.GetActiveAttrib(program, index, bufsize, length, size, type, name);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1467,7 +1485,7 @@ inline void QOpenGLFunctions::glGetActiveUniform(GLuint program, GLuint index, G
     ::glGetActiveUniform(program, index, bufsize, length, size, type, name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetActiveUniform(program, index, bufsize, length, size, type, name);
+    d_ptr->f.GetActiveUniform(program, index, bufsize, length, size, type, name);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1478,7 +1496,7 @@ inline void QOpenGLFunctions::glGetAttachedShaders(GLuint program, GLsizei maxco
     ::glGetAttachedShaders(program, maxcount, count, shaders);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetAttachedShaders(program, maxcount, count, shaders);
+    d_ptr->f.GetAttachedShaders(program, maxcount, count, shaders);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1489,7 +1507,7 @@ inline GLint QOpenGLFunctions::glGetAttribLocation(GLuint program, const char* n
     GLint result = ::glGetAttribLocation(program, name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    GLint result = d_ptr->GetAttribLocation(program, name);
+    GLint result = d_ptr->f.GetAttribLocation(program, name);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
@@ -1501,7 +1519,7 @@ inline void QOpenGLFunctions::glGetBufferParameteriv(GLenum target, GLenum pname
     ::glGetBufferParameteriv(target, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetBufferParameteriv(target, pname, params);
+    d_ptr->f.GetBufferParameteriv(target, pname, params);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1512,7 +1530,7 @@ inline void QOpenGLFunctions::glGetFramebufferAttachmentParameteriv(GLenum targe
     ::glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_ptr->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1523,7 +1541,7 @@ inline void QOpenGLFunctions::glGetProgramiv(GLuint program, GLenum pname, GLint
     ::glGetProgramiv(program, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetProgramiv(program, pname, params);
+    d_ptr->f.GetProgramiv(program, pname, params);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1534,7 +1552,7 @@ inline void QOpenGLFunctions::glGetProgramInfoLog(GLuint program, GLsizei bufsiz
     ::glGetProgramInfoLog(program, bufsize, length, infolog);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetProgramInfoLog(program, bufsize, length, infolog);
+    d_ptr->f.GetProgramInfoLog(program, bufsize, length, infolog);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1545,7 +1563,7 @@ inline void QOpenGLFunctions::glGetRenderbufferParameteriv(GLenum target, GLenum
     ::glGetRenderbufferParameteriv(target, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetRenderbufferParameteriv(target, pname, params);
+    d_ptr->f.GetRenderbufferParameteriv(target, pname, params);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1556,7 +1574,7 @@ inline void QOpenGLFunctions::glGetShaderiv(GLuint shader, GLenum pname, GLint*
     ::glGetShaderiv(shader, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetShaderiv(shader, pname, params);
+    d_ptr->f.GetShaderiv(shader, pname, params);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1567,7 +1585,7 @@ inline void QOpenGLFunctions::glGetShaderInfoLog(GLuint shader, GLsizei bufsize,
     ::glGetShaderInfoLog(shader, bufsize, length, infolog);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetShaderInfoLog(shader, bufsize, length, infolog);
+    d_ptr->f.GetShaderInfoLog(shader, bufsize, length, infolog);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1578,7 +1596,7 @@ inline void QOpenGLFunctions::glGetShaderPrecisionFormat(GLenum shadertype, GLen
     ::glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+    d_ptr->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1589,7 +1607,7 @@ inline void QOpenGLFunctions::glGetShaderSource(GLuint shader, GLsizei bufsize,
     ::glGetShaderSource(shader, bufsize, length, source);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetShaderSource(shader, bufsize, length, source);
+    d_ptr->f.GetShaderSource(shader, bufsize, length, source);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1600,7 +1618,7 @@ inline void QOpenGLFunctions::glGetUniformfv(GLuint program, GLint location, GLf
     ::glGetUniformfv(program, location, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetUniformfv(program, location, params);
+    d_ptr->f.GetUniformfv(program, location, params);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1611,7 +1629,7 @@ inline void QOpenGLFunctions::glGetUniformiv(GLuint program, GLint location, GLi
     ::glGetUniformiv(program, location, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetUniformiv(program, location, params);
+    d_ptr->f.GetUniformiv(program, location, params);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1622,7 +1640,7 @@ inline GLint QOpenGLFunctions::glGetUniformLocation(GLuint program, const char*
     GLint result = ::glGetUniformLocation(program, name);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    GLint result = d_ptr->GetUniformLocation(program, name);
+    GLint result = d_ptr->f.GetUniformLocation(program, name);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
@@ -1634,7 +1652,7 @@ inline void QOpenGLFunctions::glGetVertexAttribfv(GLuint index, GLenum pname, GL
     ::glGetVertexAttribfv(index, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetVertexAttribfv(index, pname, params);
+    d_ptr->f.GetVertexAttribfv(index, pname, params);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1645,7 +1663,7 @@ inline void QOpenGLFunctions::glGetVertexAttribiv(GLuint index, GLenum pname, GL
     ::glGetVertexAttribiv(index, pname, params);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetVertexAttribiv(index, pname, params);
+    d_ptr->f.GetVertexAttribiv(index, pname, params);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1656,7 +1674,7 @@ inline void QOpenGLFunctions::glGetVertexAttribPointerv(GLuint index, GLenum pna
     ::glGetVertexAttribPointerv(index, pname, pointer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->GetVertexAttribPointerv(index, pname, pointer);
+    d_ptr->f.GetVertexAttribPointerv(index, pname, pointer);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1667,7 +1685,7 @@ inline GLboolean QOpenGLFunctions::glIsBuffer(GLuint buffer)
     GLboolean result = ::glIsBuffer(buffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    GLboolean result = d_ptr->IsBuffer(buffer);
+    GLboolean result = d_ptr->f.IsBuffer(buffer);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
@@ -1679,7 +1697,7 @@ inline GLboolean QOpenGLFunctions::glIsFramebuffer(GLuint framebuffer)
     GLboolean result = ::glIsFramebuffer(framebuffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    GLboolean result = d_ptr->IsFramebuffer(framebuffer);
+    GLboolean result = d_ptr->f.IsFramebuffer(framebuffer);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
@@ -1691,7 +1709,7 @@ inline GLboolean QOpenGLFunctions::glIsProgram(GLuint program)
     GLboolean result = ::glIsProgram(program);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    GLboolean result = d_ptr->IsProgram(program);
+    GLboolean result = d_ptr->f.IsProgram(program);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
@@ -1703,7 +1721,7 @@ inline GLboolean QOpenGLFunctions::glIsRenderbuffer(GLuint renderbuffer)
     GLboolean result = ::glIsRenderbuffer(renderbuffer);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    GLboolean result = d_ptr->IsRenderbuffer(renderbuffer);
+    GLboolean result = d_ptr->f.IsRenderbuffer(renderbuffer);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
@@ -1715,7 +1733,7 @@ inline GLboolean QOpenGLFunctions::glIsShader(GLuint shader)
     GLboolean result = ::glIsShader(shader);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    GLboolean result = d_ptr->IsShader(shader);
+    GLboolean result = d_ptr->f.IsShader(shader);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
     return result;
@@ -1727,7 +1745,7 @@ inline void QOpenGLFunctions::glLinkProgram(GLuint program)
     ::glLinkProgram(program);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->LinkProgram(program);
+    d_ptr->f.LinkProgram(program);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1738,7 +1756,7 @@ inline void QOpenGLFunctions::glReleaseShaderCompiler()
     ::glReleaseShaderCompiler();
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->ReleaseShaderCompiler();
+    d_ptr->f.ReleaseShaderCompiler();
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1749,7 +1767,7 @@ inline void QOpenGLFunctions::glRenderbufferStorage(GLenum target, GLenum intern
     ::glRenderbufferStorage(target, internalformat, width, height);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->RenderbufferStorage(target, internalformat, width, height);
+    d_ptr->f.RenderbufferStorage(target, internalformat, width, height);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1760,7 +1778,7 @@ inline void QOpenGLFunctions::glSampleCoverage(GLclampf value, GLboolean invert)
     ::glSampleCoverage(value, invert);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->SampleCoverage(value, invert);
+    d_ptr->f.SampleCoverage(value, invert);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1771,7 +1789,7 @@ inline void QOpenGLFunctions::glShaderBinary(GLint n, const GLuint* shaders, GLe
     ::glShaderBinary(n, shaders, binaryformat, binary, length);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->ShaderBinary(n, shaders, binaryformat, binary, length);
+    d_ptr->f.ShaderBinary(n, shaders, binaryformat, binary, length);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1782,7 +1800,7 @@ inline void QOpenGLFunctions::glShaderSource(GLuint shader, GLsizei count, const
     ::glShaderSource(shader, count, string, length);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->ShaderSource(shader, count, string, length);
+    d_ptr->f.ShaderSource(shader, count, string, length);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1793,7 +1811,7 @@ inline void QOpenGLFunctions::glStencilFuncSeparate(GLenum face, GLenum func, GL
     ::glStencilFuncSeparate(face, func, ref, mask);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->StencilFuncSeparate(face, func, ref, mask);
+    d_ptr->f.StencilFuncSeparate(face, func, ref, mask);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1804,7 +1822,7 @@ inline void QOpenGLFunctions::glStencilMaskSeparate(GLenum face, GLuint mask)
     ::glStencilMaskSeparate(face, mask);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->StencilMaskSeparate(face, mask);
+    d_ptr->f.StencilMaskSeparate(face, mask);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1815,7 +1833,7 @@ inline void QOpenGLFunctions::glStencilOpSeparate(GLenum face, GLenum fail, GLen
     ::glStencilOpSeparate(face, fail, zfail, zpass);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->StencilOpSeparate(face, fail, zfail, zpass);
+    d_ptr->f.StencilOpSeparate(face, fail, zfail, zpass);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1826,7 +1844,7 @@ inline void QOpenGLFunctions::glUniform1f(GLint location, GLfloat x)
     ::glUniform1f(location, x);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Uniform1f(location, x);
+    d_ptr->f.Uniform1f(location, x);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1837,7 +1855,7 @@ inline void QOpenGLFunctions::glUniform1fv(GLint location, GLsizei count, const
     ::glUniform1fv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Uniform1fv(location, count, v);
+    d_ptr->f.Uniform1fv(location, count, v);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1848,7 +1866,7 @@ inline void QOpenGLFunctions::glUniform1i(GLint location, GLint x)
     ::glUniform1i(location, x);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Uniform1i(location, x);
+    d_ptr->f.Uniform1i(location, x);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1859,7 +1877,7 @@ inline void QOpenGLFunctions::glUniform1iv(GLint location, GLsizei count, const
     ::glUniform1iv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Uniform1iv(location, count, v);
+    d_ptr->f.Uniform1iv(location, count, v);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1870,7 +1888,7 @@ inline void QOpenGLFunctions::glUniform2f(GLint location, GLfloat x, GLfloat y)
     ::glUniform2f(location, x, y);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Uniform2f(location, x, y);
+    d_ptr->f.Uniform2f(location, x, y);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1881,7 +1899,7 @@ inline void QOpenGLFunctions::glUniform2fv(GLint location, GLsizei count, const
     ::glUniform2fv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Uniform2fv(location, count, v);
+    d_ptr->f.Uniform2fv(location, count, v);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1892,7 +1910,7 @@ inline void QOpenGLFunctions::glUniform2i(GLint location, GLint x, GLint y)
     ::glUniform2i(location, x, y);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Uniform2i(location, x, y);
+    d_ptr->f.Uniform2i(location, x, y);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1903,7 +1921,7 @@ inline void QOpenGLFunctions::glUniform2iv(GLint location, GLsizei count, const
     ::glUniform2iv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Uniform2iv(location, count, v);
+    d_ptr->f.Uniform2iv(location, count, v);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1914,7 +1932,7 @@ inline void QOpenGLFunctions::glUniform3f(GLint location, GLfloat x, GLfloat y,
     ::glUniform3f(location, x, y, z);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Uniform3f(location, x, y, z);
+    d_ptr->f.Uniform3f(location, x, y, z);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1925,7 +1943,7 @@ inline void QOpenGLFunctions::glUniform3fv(GLint location, GLsizei count, const
     ::glUniform3fv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Uniform3fv(location, count, v);
+    d_ptr->f.Uniform3fv(location, count, v);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1936,7 +1954,7 @@ inline void QOpenGLFunctions::glUniform3i(GLint location, GLint x, GLint y, GLin
     ::glUniform3i(location, x, y, z);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Uniform3i(location, x, y, z);
+    d_ptr->f.Uniform3i(location, x, y, z);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1947,7 +1965,7 @@ inline void QOpenGLFunctions::glUniform3iv(GLint location, GLsizei count, const
     ::glUniform3iv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Uniform3iv(location, count, v);
+    d_ptr->f.Uniform3iv(location, count, v);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1958,7 +1976,7 @@ inline void QOpenGLFunctions::glUniform4f(GLint location, GLfloat x, GLfloat y,
     ::glUniform4f(location, x, y, z, w);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Uniform4f(location, x, y, z, w);
+    d_ptr->f.Uniform4f(location, x, y, z, w);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1969,7 +1987,7 @@ inline void QOpenGLFunctions::glUniform4fv(GLint location, GLsizei count, const
     ::glUniform4fv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Uniform4fv(location, count, v);
+    d_ptr->f.Uniform4fv(location, count, v);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1980,7 +1998,7 @@ inline void QOpenGLFunctions::glUniform4i(GLint location, GLint x, GLint y, GLin
     ::glUniform4i(location, x, y, z, w);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Uniform4i(location, x, y, z, w);
+    d_ptr->f.Uniform4i(location, x, y, z, w);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -1991,7 +2009,7 @@ inline void QOpenGLFunctions::glUniform4iv(GLint location, GLsizei count, const
     ::glUniform4iv(location, count, v);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->Uniform4iv(location, count, v);
+    d_ptr->f.Uniform4iv(location, count, v);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -2002,7 +2020,7 @@ inline void QOpenGLFunctions::glUniformMatrix2fv(GLint location, GLsizei count,
     ::glUniformMatrix2fv(location, count, transpose, value);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->UniformMatrix2fv(location, count, transpose, value);
+    d_ptr->f.UniformMatrix2fv(location, count, transpose, value);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -2013,7 +2031,7 @@ inline void QOpenGLFunctions::glUniformMatrix3fv(GLint location, GLsizei count,
     ::glUniformMatrix3fv(location, count, transpose, value);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->UniformMatrix3fv(location, count, transpose, value);
+    d_ptr->f.UniformMatrix3fv(location, count, transpose, value);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -2024,7 +2042,7 @@ inline void QOpenGLFunctions::glUniformMatrix4fv(GLint location, GLsizei count,
     ::glUniformMatrix4fv(location, count, transpose, value);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->UniformMatrix4fv(location, count, transpose, value);
+    d_ptr->f.UniformMatrix4fv(location, count, transpose, value);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -2035,7 +2053,7 @@ inline void QOpenGLFunctions::glUseProgram(GLuint program)
     ::glUseProgram(program);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->UseProgram(program);
+    d_ptr->f.UseProgram(program);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -2046,7 +2064,7 @@ inline void QOpenGLFunctions::glValidateProgram(GLuint program)
     ::glValidateProgram(program);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->ValidateProgram(program);
+    d_ptr->f.ValidateProgram(program);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -2057,7 +2075,7 @@ inline void QOpenGLFunctions::glVertexAttrib1f(GLuint indx, GLfloat x)
     ::glVertexAttrib1f(indx, x);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->VertexAttrib1f(indx, x);
+    d_ptr->f.VertexAttrib1f(indx, x);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -2068,7 +2086,7 @@ inline void QOpenGLFunctions::glVertexAttrib1fv(GLuint indx, const GLfloat* valu
     ::glVertexAttrib1fv(indx, values);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->VertexAttrib1fv(indx, values);
+    d_ptr->f.VertexAttrib1fv(indx, values);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -2079,7 +2097,7 @@ inline void QOpenGLFunctions::glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y
     ::glVertexAttrib2f(indx, x, y);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->VertexAttrib2f(indx, x, y);
+    d_ptr->f.VertexAttrib2f(indx, x, y);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -2090,7 +2108,7 @@ inline void QOpenGLFunctions::glVertexAttrib2fv(GLuint indx, const GLfloat* valu
     ::glVertexAttrib2fv(indx, values);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->VertexAttrib2fv(indx, values);
+    d_ptr->f.VertexAttrib2fv(indx, values);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -2101,7 +2119,7 @@ inline void QOpenGLFunctions::glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y
     ::glVertexAttrib3f(indx, x, y, z);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->VertexAttrib3f(indx, x, y, z);
+    d_ptr->f.VertexAttrib3f(indx, x, y, z);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -2112,7 +2130,7 @@ inline void QOpenGLFunctions::glVertexAttrib3fv(GLuint indx, const GLfloat* valu
     ::glVertexAttrib3fv(indx, values);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->VertexAttrib3fv(indx, values);
+    d_ptr->f.VertexAttrib3fv(indx, values);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -2123,7 +2141,7 @@ inline void QOpenGLFunctions::glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y
     ::glVertexAttrib4f(indx, x, y, z, w);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->VertexAttrib4f(indx, x, y, z, w);
+    d_ptr->f.VertexAttrib4f(indx, x, y, z, w);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -2134,7 +2152,7 @@ inline void QOpenGLFunctions::glVertexAttrib4fv(GLuint indx, const GLfloat* valu
     ::glVertexAttrib4fv(indx, values);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->VertexAttrib4fv(indx, values);
+    d_ptr->f.VertexAttrib4fv(indx, values);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
@@ -2145,11 +2163,15 @@ inline void QOpenGLFunctions::glVertexAttribPointer(GLuint indx, GLint size, GLe
     ::glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
 #else
     Q_ASSERT(QOpenGLFunctions::isInitialized(d_ptr));
-    d_ptr->VertexAttribPointer(indx, size, type, normalized, stride, ptr);
+    d_ptr->f.VertexAttribPointer(indx, size, type, normalized, stride, ptr);
 #endif
     Q_OPENGL_FUNCTIONS_DEBUG
 }
 
+#undef QT_OPENGL_DECLARE_FUNCTIONS
+#undef QT_OPENGL_COUNT_FUNCTIONS
+#undef QT_OPENGL_DECLARE
+
 QT_END_NAMESPACE
 
 #endif // QT_NO_OPENGL
diff --git a/src/gui/opengl/qopenglfunctions_1_0.cpp b/src/gui/opengl/qopenglfunctions_1_0.cpp
index dcaff4b300b..9d5a76380ad 100644
--- a/src/gui/opengl/qopenglfunctions_1_0.cpp
+++ b/src/gui/opengl/qopenglfunctions_1_0.cpp
@@ -74,14 +74,12 @@ QOpenGLFunctions_1_0::QOpenGLFunctions_1_0()
 
 QOpenGLFunctions_1_0::~QOpenGLFunctions_1_0()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_1_0::initializeOpenGLFunctions()
@@ -100,18 +98,10 @@ bool QOpenGLFunctions_1_0::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_1_0.h b/src/gui/opengl/qopenglfunctions_1_0.h
index cfbe7f642d8..825a6255a3a 100644
--- a/src/gui/opengl/qopenglfunctions_1_0.h
+++ b/src/gui/opengl/qopenglfunctions_1_0.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -389,1534 +390,1534 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_1_0::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_0::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_1_0::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_1_0::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_1_0::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_1_0::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_1_0::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_1_0::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_0::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_1_0::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_1_0::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_1_0::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_1_0::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_1_0::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_1_0::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_1_0::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_1_0::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_1_0::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_1_0::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_1_0::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_0::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_1_0::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_1_0::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_1_0::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_0::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_1_0::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_1_0::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_0::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_0::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_0::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_1_0::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_1_0::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_1_0::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_1_0::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_1_0::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_1_0::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_0::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_0::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_0::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_0::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_1_0::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_1_0::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_1_0::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_1_0::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_1_0::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_0::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_0::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_1_0::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_0::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_0::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_1_0::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_1_0::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_1_0::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_1_0::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_1_0::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_1_0::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_1_0::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_0::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_0::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_0::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_1_0::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_0::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_1_0::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_0::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_0::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_0::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_1_0::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_1_0::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_1_0::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_1_0::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_1_0::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_1_0::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_1_0::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_1_0::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_1_0::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_1_0::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_1_0::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_1_0::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_1_0::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_1_0::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_1_0::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_1_0::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_1_0::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_1_0::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_1_0::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_1_0::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_1_0::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_1_0::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_1_0::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_1_0::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_1_0::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_1_0::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_1_0::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_0::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_1_0::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_1_0::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_1_0::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_1_0::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_1_0::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_1_0::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_1_0::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_1_0::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_1_0::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_1_0::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_1_0::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_0::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_0::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_1_0::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_1_0::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_0::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_0::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_0::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_0::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_0::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_0::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_0::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_1_0::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_0::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_0::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_0::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_0::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_0::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_1_0::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_1_0::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_1_0::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_1_0::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_1_0::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_1_0::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_1_0::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_1_0::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_1_0::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_1_0::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_1_0::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_0::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_0::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_0::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_0::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_0::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_0::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_0::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_0::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_0::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_0::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_0::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_0::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_0::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_0::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_0::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_1_0::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_0::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_1_0::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_1_0::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_1_0::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_1_0::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_1_0::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_1_0::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_1_0::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_1_0::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_1_1.cpp b/src/gui/opengl/qopenglfunctions_1_1.cpp
index 08bc20b81fd..57385f19279 100644
--- a/src/gui/opengl/qopenglfunctions_1_1.cpp
+++ b/src/gui/opengl/qopenglfunctions_1_1.cpp
@@ -76,22 +76,18 @@ QOpenGLFunctions_1_1::QOpenGLFunctions_1_1()
 
 QOpenGLFunctions_1_1::~QOpenGLFunctions_1_1()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
-    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        delete d_1_1_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
+    if (d_1_1_Deprecated)
+        d_1_1_Deprecated->refs.deref();
+    Q_ASSERT(d_1_1_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_1_1::initializeOpenGLFunctions()
@@ -110,34 +106,18 @@ bool QOpenGLFunctions_1_1::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_1_1.h b/src/gui/opengl/qopenglfunctions_1_1.h
index b51028168ec..f312258f008 100644
--- a/src/gui/opengl/qopenglfunctions_1_1.h
+++ b/src/gui/opengl/qopenglfunctions_1_1.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -425,1688 +426,1688 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_1_1::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_1::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_1_1::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_1_1::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_1_1::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_1_1::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_1_1::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_1_1::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_1::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_1_1::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_1_1::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_1_1::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_1_1::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_1_1::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_1_1::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_1_1::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_1_1::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_1_1::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_1_1::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_1_1::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_1::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_1_1::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_1_1::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_1_1::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_1::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_1_1::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_1_1::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_1::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_1::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_1::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_1_1::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_1_1::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_1_1::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_1_1::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_1_1::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline void QOpenGLFunctions_1_1::glIndexubv(const GLubyte *c)
 {
-    d_1_1_Deprecated->Indexubv(c);
+    d_1_1_Deprecated->f.Indexubv(c);
 }
 
 inline void QOpenGLFunctions_1_1::glIndexub(GLubyte c)
 {
-    d_1_1_Deprecated->Indexub(c);
+    d_1_1_Deprecated->f.Indexub(c);
 }
 
 inline GLboolean QOpenGLFunctions_1_1::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_1_1::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_1_1::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_1_1::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_1_1::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_1::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_1::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_1::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_1::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_1_1::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_1_1::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_1_1::glGetPointerv(GLenum pname, GLvoid* *params)
 {
-    d_1_1_Deprecated->GetPointerv(pname, params);
+    d_1_1_Deprecated->f.GetPointerv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_1_1::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_1_1::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_1::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_1::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_1::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_1::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_1_1::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_1_1::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_1_1::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_1_1::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_1_1::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_1::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_1::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_1_1::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_1::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_1::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_1_1::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_1_1::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_1_1::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_1_1::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_1_1::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_1_1::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_1_1::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_1::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_1::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_1::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_1_1::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_1::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_1_1::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_1::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_1::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_1::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_1_1::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_1_1::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_1_1::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_1_1::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_1_1::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_1_1::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_1_1::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_1_1::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_1_1::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_1_1::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_1_1::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_1_1::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_1_1::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_1_1::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_1_1::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_1_1::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_1_1::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_1_1::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_1_1::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_1_1::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_1_1::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_1_1::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_1_1::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_1_1::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_1_1::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_1_1::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_1_1::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_1::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_1_1::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_1_1::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_1_1::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_1_1::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_1_1::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_1_1::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_1_1::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_1_1::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_1_1::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_1_1::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_1_1::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_1::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_1::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_1_1::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_1_1::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_1::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_1::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_1::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_1::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_1::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_1::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_1::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_1_1::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_1::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_1::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_1::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_1::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_1::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_1_1::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_1_1::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_1_1::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_1_1::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_1_1::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_1_1::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_1_1::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_1_1::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_1_1::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_1_1::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_1_1::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_1::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_1::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_1::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_1::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_1::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_1::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_1::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_1::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_1::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_1::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_1::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_1::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_1::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_1::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_1::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_1_1::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_1::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_1_1::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_1_1::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_1_1::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_1_1::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_1_1::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_1_1::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_1_1::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_1_1::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
 // OpenGL 1.1 deprecated functions
 inline void QOpenGLFunctions_1_1::glPushClientAttrib(GLbitfield mask)
 {
-    d_1_1_Deprecated->PushClientAttrib(mask);
+    d_1_1_Deprecated->f.PushClientAttrib(mask);
 }
 
 inline void QOpenGLFunctions_1_1::glPopClientAttrib()
 {
-    d_1_1_Deprecated->PopClientAttrib();
+    d_1_1_Deprecated->f.PopClientAttrib();
 }
 
 inline void QOpenGLFunctions_1_1::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 {
-    d_1_1_Deprecated->PrioritizeTextures(n, textures, priorities);
+    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
 }
 
 inline GLboolean QOpenGLFunctions_1_1::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-    return d_1_1_Deprecated->AreTexturesResident(n, textures, residences);
+    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
 }
 
 inline void QOpenGLFunctions_1_1::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->VertexPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_1::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->TexCoordPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_1::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->NormalPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_1::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->InterleavedArrays(format, stride, pointer);
+    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_1::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->IndexPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_1::glEnableClientState(GLenum array)
 {
-    d_1_1_Deprecated->EnableClientState(array);
+    d_1_1_Deprecated->f.EnableClientState(array);
 }
 
 inline void QOpenGLFunctions_1_1::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->EdgeFlagPointer(stride, pointer);
+    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_1::glDisableClientState(GLenum array)
 {
-    d_1_1_Deprecated->DisableClientState(array);
+    d_1_1_Deprecated->f.DisableClientState(array);
 }
 
 inline void QOpenGLFunctions_1_1::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->ColorPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_1::glArrayElement(GLint i)
 {
-    d_1_1_Deprecated->ArrayElement(i);
+    d_1_1_Deprecated->f.ArrayElement(i);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_1_2.cpp b/src/gui/opengl/qopenglfunctions_1_2.cpp
index bbc524527cd..9eaa13862d2 100644
--- a/src/gui/opengl/qopenglfunctions_1_2.cpp
+++ b/src/gui/opengl/qopenglfunctions_1_2.cpp
@@ -78,30 +78,24 @@ QOpenGLFunctions_1_2::QOpenGLFunctions_1_2()
 
 QOpenGLFunctions_1_2::~QOpenGLFunctions_1_2()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
-    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        delete d_1_1_Deprecated;
-    }
-    if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        delete d_1_2_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
+    if (d_1_1_Deprecated)
+        d_1_1_Deprecated->refs.deref();
+    Q_ASSERT(d_1_1_Deprecated->refs.load());
+    if (d_1_2_Deprecated)
+        d_1_2_Deprecated->refs.deref();
+    Q_ASSERT(d_1_2_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_1_2::initializeOpenGLFunctions()
@@ -120,50 +114,26 @@ bool QOpenGLFunctions_1_2::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_1_2.h b/src/gui/opengl/qopenglfunctions_1_2.h
index 74d688e740d..fd4e7f74f91 100644
--- a/src/gui/opengl/qopenglfunctions_1_2.h
+++ b/src/gui/opengl/qopenglfunctions_1_2.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -469,1882 +470,1882 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_1_2::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_2::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_1_2::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_1_2::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_1_2::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_1_2::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_1_2::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_1_2::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_2::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_1_2::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_1_2::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_1_2::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_1_2::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_1_2::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_1_2::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_1_2::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_1_2::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_1_2::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_1_2::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_1_2::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_2::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_1_2::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_1_2::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_1_2::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_2::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_1_2::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_1_2::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_2::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_2::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_2::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_1_2::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_1_2::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_1_2::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_1_2::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_1_2::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline void QOpenGLFunctions_1_2::glIndexubv(const GLubyte *c)
 {
-    d_1_1_Deprecated->Indexubv(c);
+    d_1_1_Deprecated->f.Indexubv(c);
 }
 
 inline void QOpenGLFunctions_1_2::glIndexub(GLubyte c)
 {
-    d_1_1_Deprecated->Indexub(c);
+    d_1_1_Deprecated->f.Indexub(c);
 }
 
 inline GLboolean QOpenGLFunctions_1_2::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_1_2::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_1_2::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_1_2::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_1_2::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_2::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_2::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_2::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_2::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_1_2::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_1_2::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_1_2::glGetPointerv(GLenum pname, GLvoid* *params)
 {
-    d_1_1_Deprecated->GetPointerv(pname, params);
+    d_1_1_Deprecated->f.GetPointerv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_1_2::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_1_2::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_2::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_2::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_2::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_1_2::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_1_2::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_1_2::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_2::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_2::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_2::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_2::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_1_2::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_1_2::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_1_2::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_1_2::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_1_2::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_2::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_2::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_1_2::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_2::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_2::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_1_2::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_1_2::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_1_2::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_1_2::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_1_2::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_1_2::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_1_2::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_2::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_2::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_2::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_1_2::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_2::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_1_2::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_2::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_2::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_2::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_1_2::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_1_2::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_1_2::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_1_2::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_1_2::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_1_2::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_1_2::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_1_2::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_1_2::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_1_2::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_1_2::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_1_2::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_1_2::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_1_2::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_1_2::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_1_2::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_1_2::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_1_2::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_1_2::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_1_2::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_1_2::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_1_2::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_1_2::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_1_2::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_1_2::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_1_2::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_1_2::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_2::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_1_2::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_1_2::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_1_2::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_1_2::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_1_2::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_1_2::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_1_2::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_1_2::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_1_2::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_1_2::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_1_2::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_2::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_1_2::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_1_2::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_2::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_2::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_2::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_2::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_2::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_2::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_2::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_1_2::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_2::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_2::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_2::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_2::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_2::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_1_2::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_1_2::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_1_2::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_1_2::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_1_2::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_1_2::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_1_2::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_1_2::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_1_2::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_1_2::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_1_2::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_2::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_2::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_2::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_2::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_2::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_2::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_2::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_2::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_2::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_2::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_2::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_2::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_2::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_2::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_2::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_1_2::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_2::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_1_2::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_1_2::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_1_2::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_1_2::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_1_2::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_1_2::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_1_2::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_1_2::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
 // OpenGL 1.1 deprecated functions
 inline void QOpenGLFunctions_1_2::glPushClientAttrib(GLbitfield mask)
 {
-    d_1_1_Deprecated->PushClientAttrib(mask);
+    d_1_1_Deprecated->f.PushClientAttrib(mask);
 }
 
 inline void QOpenGLFunctions_1_2::glPopClientAttrib()
 {
-    d_1_1_Deprecated->PopClientAttrib();
+    d_1_1_Deprecated->f.PopClientAttrib();
 }
 
 inline void QOpenGLFunctions_1_2::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 {
-    d_1_1_Deprecated->PrioritizeTextures(n, textures, priorities);
+    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
 }
 
 inline GLboolean QOpenGLFunctions_1_2::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-    return d_1_1_Deprecated->AreTexturesResident(n, textures, residences);
+    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
 }
 
 inline void QOpenGLFunctions_1_2::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->VertexPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_2::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->TexCoordPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_2::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->NormalPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_2::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->InterleavedArrays(format, stride, pointer);
+    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_2::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->IndexPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_2::glEnableClientState(GLenum array)
 {
-    d_1_1_Deprecated->EnableClientState(array);
+    d_1_1_Deprecated->f.EnableClientState(array);
 }
 
 inline void QOpenGLFunctions_1_2::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->EdgeFlagPointer(stride, pointer);
+    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_2::glDisableClientState(GLenum array)
 {
-    d_1_1_Deprecated->DisableClientState(array);
+    d_1_1_Deprecated->f.DisableClientState(array);
 }
 
 inline void QOpenGLFunctions_1_2::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->ColorPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_2::glArrayElement(GLint i)
 {
-    d_1_1_Deprecated->ArrayElement(i);
+    d_1_1_Deprecated->f.ArrayElement(i);
 }
 
 
 // OpenGL 1.2 deprecated functions
 inline void QOpenGLFunctions_1_2::glResetMinmax(GLenum target)
 {
-    d_1_2_Deprecated->ResetMinmax(target);
+    d_1_2_Deprecated->f.ResetMinmax(target);
 }
 
 inline void QOpenGLFunctions_1_2::glResetHistogram(GLenum target)
 {
-    d_1_2_Deprecated->ResetHistogram(target);
+    d_1_2_Deprecated->f.ResetHistogram(target);
 }
 
 inline void QOpenGLFunctions_1_2::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Minmax(target, internalformat, sink);
+    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_1_2::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Histogram(target, width, internalformat, sink);
+    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_1_2::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetMinmax(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_1_2::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetHistogramParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetHistogramParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetHistogram(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_1_2::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
 {
-    d_1_2_Deprecated->SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
+    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
 }
 
 inline void QOpenGLFunctions_1_2::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
 {
-    d_1_2_Deprecated->GetSeparableFilter(target, format, type, row, column, span);
+    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
 }
 
 inline void QOpenGLFunctions_1_2::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
 {
-    d_1_2_Deprecated->GetConvolutionFilter(target, format, type, image);
+    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
 }
 
 inline void QOpenGLFunctions_1_2::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
+    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_2::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter1D(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_2::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
 {
-    d_1_2_Deprecated->ConvolutionParameteri(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
 {
-    d_1_2_Deprecated->ConvolutionParameterf(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
 }
 
 inline void QOpenGLFunctions_1_2::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter1D(target, internalformat, width, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
 }
 
 inline void QOpenGLFunctions_1_2::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorSubTable(target, start, x, y, width);
+    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_2::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
 {
-    d_1_2_Deprecated->ColorSubTable(target, start, count, format, type, data);
+    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
 }
 
 inline void QOpenGLFunctions_1_2::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
 {
-    d_1_2_Deprecated->GetColorTable(target, format, type, table);
+    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
 }
 
 inline void QOpenGLFunctions_1_2::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorTable(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_2::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_2::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
 {
-    d_1_2_Deprecated->ColorTable(target, internalformat, width, format, type, table);
+    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_1_3.cpp b/src/gui/opengl/qopenglfunctions_1_3.cpp
index c7a9f2a1f23..62119973029 100644
--- a/src/gui/opengl/qopenglfunctions_1_3.cpp
+++ b/src/gui/opengl/qopenglfunctions_1_3.cpp
@@ -80,38 +80,30 @@ QOpenGLFunctions_1_3::QOpenGLFunctions_1_3()
 
 QOpenGLFunctions_1_3::~QOpenGLFunctions_1_3()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
-    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        delete d_1_1_Deprecated;
-    }
-    if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        delete d_1_2_Deprecated;
-    }
-    if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        delete d_1_3_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
+    if (d_1_1_Deprecated)
+        d_1_1_Deprecated->refs.deref();
+    Q_ASSERT(d_1_1_Deprecated->refs.load());
+    if (d_1_2_Deprecated)
+        d_1_2_Deprecated->refs.deref();
+    Q_ASSERT(d_1_2_Deprecated->refs.load());
+    if (d_1_3_Deprecated)
+        d_1_3_Deprecated->refs.deref();
+    Q_ASSERT(d_1_3_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_1_3::initializeOpenGLFunctions()
@@ -130,66 +122,34 @@ bool QOpenGLFunctions_1_3::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_1_3.h b/src/gui/opengl/qopenglfunctions_1_3.h
index c75c514ae0c..a8509c46c58 100644
--- a/src/gui/opengl/qopenglfunctions_1_3.h
+++ b/src/gui/opengl/qopenglfunctions_1_3.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -521,2116 +522,2116 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_1_3::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_3::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_1_3::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_1_3::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_1_3::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_1_3::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_1_3::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_1_3::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_3::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_1_3::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_1_3::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_1_3::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_1_3::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_1_3::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_1_3::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_1_3::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_1_3::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_1_3::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_1_3::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_1_3::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_3::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_1_3::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_1_3::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_1_3::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_3::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_1_3::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_1_3::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_3::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_3::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_3::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_1_3::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_1_3::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_1_3::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_1_3::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_1_3::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline void QOpenGLFunctions_1_3::glIndexubv(const GLubyte *c)
 {
-    d_1_1_Deprecated->Indexubv(c);
+    d_1_1_Deprecated->f.Indexubv(c);
 }
 
 inline void QOpenGLFunctions_1_3::glIndexub(GLubyte c)
 {
-    d_1_1_Deprecated->Indexub(c);
+    d_1_1_Deprecated->f.Indexub(c);
 }
 
 inline GLboolean QOpenGLFunctions_1_3::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_1_3::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_1_3::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_1_3::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_1_3::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_3::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_3::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_3::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_3::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_1_3::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_1_3::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_1_3::glGetPointerv(GLenum pname, GLvoid* *params)
 {
-    d_1_1_Deprecated->GetPointerv(pname, params);
+    d_1_1_Deprecated->f.GetPointerv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_1_3::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_1_3::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_3::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_3::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_3::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_1_3::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_1_3::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_1_3::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_1_3::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_3::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_3::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_3::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_3::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_3::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_3::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_1_3::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_1_3::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_3::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_3::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_3::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_3::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_1_3::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_1_3::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_1_3::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_1_3::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_1_3::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_3::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_3::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_1_3::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_3::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_3::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_1_3::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_1_3::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_1_3::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_1_3::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_1_3::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_1_3::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_1_3::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_3::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_3::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_3::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_1_3::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_3::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_1_3::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_3::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_3::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_3::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_1_3::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_1_3::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_1_3::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_1_3::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_1_3::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_1_3::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_1_3::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_1_3::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_1_3::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_1_3::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_1_3::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_1_3::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_1_3::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_1_3::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_1_3::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_1_3::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_1_3::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_1_3::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_1_3::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_1_3::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_1_3::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_1_3::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_1_3::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_1_3::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_1_3::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_1_3::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_1_3::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_3::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_1_3::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_1_3::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_1_3::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_1_3::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_1_3::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_1_3::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_1_3::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_1_3::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_1_3::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_1_3::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_1_3::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_3::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_1_3::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_1_3::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_3::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_3::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_3::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_3::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_3::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_3::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_3::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_1_3::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_3::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_3::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_3::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_3::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_3::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_1_3::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_1_3::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_1_3::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_1_3::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_1_3::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_1_3::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_1_3::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_1_3::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_1_3::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_1_3::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_1_3::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_3::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_3::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_3::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_3::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_3::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_3::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_3::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_3::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_3::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_3::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_3::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_3::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_3::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_3::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_3::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_1_3::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_3::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_1_3::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_1_3::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_1_3::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_1_3::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_1_3::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_1_3::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_1_3::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_1_3::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
 // OpenGL 1.1 deprecated functions
 inline void QOpenGLFunctions_1_3::glPushClientAttrib(GLbitfield mask)
 {
-    d_1_1_Deprecated->PushClientAttrib(mask);
+    d_1_1_Deprecated->f.PushClientAttrib(mask);
 }
 
 inline void QOpenGLFunctions_1_3::glPopClientAttrib()
 {
-    d_1_1_Deprecated->PopClientAttrib();
+    d_1_1_Deprecated->f.PopClientAttrib();
 }
 
 inline void QOpenGLFunctions_1_3::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 {
-    d_1_1_Deprecated->PrioritizeTextures(n, textures, priorities);
+    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
 }
 
 inline GLboolean QOpenGLFunctions_1_3::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-    return d_1_1_Deprecated->AreTexturesResident(n, textures, residences);
+    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
 }
 
 inline void QOpenGLFunctions_1_3::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->VertexPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_3::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->TexCoordPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_3::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->NormalPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_3::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->InterleavedArrays(format, stride, pointer);
+    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_3::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->IndexPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_3::glEnableClientState(GLenum array)
 {
-    d_1_1_Deprecated->EnableClientState(array);
+    d_1_1_Deprecated->f.EnableClientState(array);
 }
 
 inline void QOpenGLFunctions_1_3::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->EdgeFlagPointer(stride, pointer);
+    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_3::glDisableClientState(GLenum array)
 {
-    d_1_1_Deprecated->DisableClientState(array);
+    d_1_1_Deprecated->f.DisableClientState(array);
 }
 
 inline void QOpenGLFunctions_1_3::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->ColorPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_3::glArrayElement(GLint i)
 {
-    d_1_1_Deprecated->ArrayElement(i);
+    d_1_1_Deprecated->f.ArrayElement(i);
 }
 
 
 // OpenGL 1.2 deprecated functions
 inline void QOpenGLFunctions_1_3::glResetMinmax(GLenum target)
 {
-    d_1_2_Deprecated->ResetMinmax(target);
+    d_1_2_Deprecated->f.ResetMinmax(target);
 }
 
 inline void QOpenGLFunctions_1_3::glResetHistogram(GLenum target)
 {
-    d_1_2_Deprecated->ResetHistogram(target);
+    d_1_2_Deprecated->f.ResetHistogram(target);
 }
 
 inline void QOpenGLFunctions_1_3::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Minmax(target, internalformat, sink);
+    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_1_3::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Histogram(target, width, internalformat, sink);
+    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_1_3::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetMinmax(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_1_3::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetHistogramParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetHistogramParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetHistogram(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_1_3::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
 {
-    d_1_2_Deprecated->SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
+    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
 }
 
 inline void QOpenGLFunctions_1_3::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
 {
-    d_1_2_Deprecated->GetSeparableFilter(target, format, type, row, column, span);
+    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
 }
 
 inline void QOpenGLFunctions_1_3::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
 {
-    d_1_2_Deprecated->GetConvolutionFilter(target, format, type, image);
+    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
 }
 
 inline void QOpenGLFunctions_1_3::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
+    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_3::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter1D(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_3::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
 {
-    d_1_2_Deprecated->ConvolutionParameteri(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
 {
-    d_1_2_Deprecated->ConvolutionParameterf(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
 }
 
 inline void QOpenGLFunctions_1_3::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter1D(target, internalformat, width, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
 }
 
 inline void QOpenGLFunctions_1_3::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorSubTable(target, start, x, y, width);
+    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_3::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
 {
-    d_1_2_Deprecated->ColorSubTable(target, start, count, format, type, data);
+    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
 }
 
 inline void QOpenGLFunctions_1_3::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
 {
-    d_1_2_Deprecated->GetColorTable(target, format, type, table);
+    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
 }
 
 inline void QOpenGLFunctions_1_3::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorTable(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_3::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_3::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
 {
-    d_1_2_Deprecated->ColorTable(target, internalformat, width, format, type, table);
+    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
 }
 
 
 // OpenGL 1.3 deprecated functions
 inline void QOpenGLFunctions_1_3::glMultTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixd(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_3::glMultTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixf(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_3::glLoadTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixd(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_3::glLoadTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixf(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord4sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_3_Deprecated->MultiTexCoord4s(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord4iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_3_Deprecated->MultiTexCoord4i(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_3_Deprecated->MultiTexCoord4f(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_3_Deprecated->MultiTexCoord4d(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord3sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
 {
-    d_1_3_Deprecated->MultiTexCoord3s(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord3iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
 {
-    d_1_3_Deprecated->MultiTexCoord3i(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_3_Deprecated->MultiTexCoord3f(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_3_Deprecated->MultiTexCoord3d(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord2sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
 {
-    d_1_3_Deprecated->MultiTexCoord2s(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord2iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
 {
-    d_1_3_Deprecated->MultiTexCoord2i(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
 {
-    d_1_3_Deprecated->MultiTexCoord2f(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
 {
-    d_1_3_Deprecated->MultiTexCoord2d(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord1sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord1s(GLenum target, GLshort s)
 {
-    d_1_3_Deprecated->MultiTexCoord1s(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord1iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord1i(GLenum target, GLint s)
 {
-    d_1_3_Deprecated->MultiTexCoord1i(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord1f(GLenum target, GLfloat s)
 {
-    d_1_3_Deprecated->MultiTexCoord1f(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
 }
 
 inline void QOpenGLFunctions_1_3::glMultiTexCoord1d(GLenum target, GLdouble s)
 {
-    d_1_3_Deprecated->MultiTexCoord1d(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
 }
 
 inline void QOpenGLFunctions_1_3::glClientActiveTexture(GLenum texture)
 {
-    d_1_3_Deprecated->ClientActiveTexture(texture);
+    d_1_3_Deprecated->f.ClientActiveTexture(texture);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_1_4.cpp b/src/gui/opengl/qopenglfunctions_1_4.cpp
index fc712a8cf10..5ff2c24014a 100644
--- a/src/gui/opengl/qopenglfunctions_1_4.cpp
+++ b/src/gui/opengl/qopenglfunctions_1_4.cpp
@@ -82,46 +82,36 @@ QOpenGLFunctions_1_4::QOpenGLFunctions_1_4()
 
 QOpenGLFunctions_1_4::~QOpenGLFunctions_1_4()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
-    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        delete d_1_1_Deprecated;
-    }
-    if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        delete d_1_2_Deprecated;
-    }
-    if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        delete d_1_3_Deprecated;
-    }
-    if (d_1_4_Deprecated && !d_1_4_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        delete d_1_4_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
+    if (d_1_1_Deprecated)
+        d_1_1_Deprecated->refs.deref();
+    Q_ASSERT(d_1_1_Deprecated->refs.load());
+    if (d_1_2_Deprecated)
+        d_1_2_Deprecated->refs.deref();
+    Q_ASSERT(d_1_2_Deprecated->refs.load());
+    if (d_1_3_Deprecated)
+        d_1_3_Deprecated->refs.deref();
+    Q_ASSERT(d_1_3_Deprecated->refs.load());
+    if (d_1_4_Deprecated)
+        d_1_4_Deprecated->refs.deref();
+    Q_ASSERT(d_1_4_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_1_4::initializeOpenGLFunctions()
@@ -140,82 +130,42 @@ bool QOpenGLFunctions_1_4::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_1_4.h b/src/gui/opengl/qopenglfunctions_1_4.h
index 8e18e04ec5f..eeb99dbb1be 100644
--- a/src/gui/opengl/qopenglfunctions_1_4.h
+++ b/src/gui/opengl/qopenglfunctions_1_4.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -572,2345 +573,2345 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_1_4::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_4::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_1_4::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_1_4::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_1_4::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_1_4::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_1_4::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_1_4::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_4::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_1_4::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_1_4::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_1_4::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_1_4::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_1_4::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_1_4::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_1_4::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_1_4::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_1_4::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_1_4::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_1_4::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_4::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_1_4::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_1_4::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_1_4::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_4::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_1_4::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_1_4::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_4::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_4::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_4::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_1_4::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_1_4::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_1_4::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_1_4::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_1_4::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline void QOpenGLFunctions_1_4::glIndexubv(const GLubyte *c)
 {
-    d_1_1_Deprecated->Indexubv(c);
+    d_1_1_Deprecated->f.Indexubv(c);
 }
 
 inline void QOpenGLFunctions_1_4::glIndexub(GLubyte c)
 {
-    d_1_1_Deprecated->Indexub(c);
+    d_1_1_Deprecated->f.Indexub(c);
 }
 
 inline GLboolean QOpenGLFunctions_1_4::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_1_4::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_1_4::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_1_4::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_1_4::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_4::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_4::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_4::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_4::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_1_4::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_1_4::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_1_4::glGetPointerv(GLenum pname, GLvoid* *params)
 {
-    d_1_1_Deprecated->GetPointerv(pname, params);
+    d_1_1_Deprecated->f.GetPointerv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_1_4::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_1_4::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_4::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_4::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_4::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_1_4::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_1_4::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_1_4::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_1_4::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_4::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_4::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_4::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_4::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_4::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_4::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_1_4::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_1_4::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_1_4::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_1_4::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_1_4::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_1_4::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_1_4::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_4::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_4::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_1_4::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_4::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_4::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_1_4::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_1_4::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_1_4::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_1_4::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_1_4::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_1_4::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_1_4::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_4::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_4::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_4::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_1_4::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_4::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_1_4::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_4::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_4::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_4::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_1_4::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_1_4::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_1_4::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_1_4::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_1_4::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_1_4::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_1_4::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_1_4::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_1_4::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_1_4::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_1_4::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_1_4::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_1_4::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_1_4::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_1_4::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_1_4::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_1_4::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_1_4::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_1_4::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_1_4::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_1_4::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_1_4::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_1_4::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_1_4::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_1_4::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_1_4::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_1_4::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_4::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_1_4::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_1_4::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_1_4::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_1_4::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_1_4::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_1_4::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_1_4::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_1_4::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_1_4::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_1_4::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_1_4::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_4::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_1_4::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_1_4::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_4::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_4::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_4::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_4::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_4::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_4::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_4::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_1_4::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_4::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_4::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_4::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_4::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_4::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_1_4::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_1_4::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_1_4::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_1_4::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_1_4::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_1_4::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_1_4::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_1_4::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_1_4::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_1_4::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_1_4::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_4::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_4::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_4::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_4::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_4::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_4::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_4::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_4::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_4::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_4::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_4::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_4::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_4::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_4::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_4::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_4::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_1_4::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_1_4::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_1_4::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_1_4::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_1_4::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_1_4::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_1_4::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_1_4::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
 // OpenGL 1.1 deprecated functions
 inline void QOpenGLFunctions_1_4::glPushClientAttrib(GLbitfield mask)
 {
-    d_1_1_Deprecated->PushClientAttrib(mask);
+    d_1_1_Deprecated->f.PushClientAttrib(mask);
 }
 
 inline void QOpenGLFunctions_1_4::glPopClientAttrib()
 {
-    d_1_1_Deprecated->PopClientAttrib();
+    d_1_1_Deprecated->f.PopClientAttrib();
 }
 
 inline void QOpenGLFunctions_1_4::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 {
-    d_1_1_Deprecated->PrioritizeTextures(n, textures, priorities);
+    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
 }
 
 inline GLboolean QOpenGLFunctions_1_4::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-    return d_1_1_Deprecated->AreTexturesResident(n, textures, residences);
+    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
 }
 
 inline void QOpenGLFunctions_1_4::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->VertexPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_4::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->TexCoordPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_4::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->NormalPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_4::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->InterleavedArrays(format, stride, pointer);
+    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_4::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->IndexPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_4::glEnableClientState(GLenum array)
 {
-    d_1_1_Deprecated->EnableClientState(array);
+    d_1_1_Deprecated->f.EnableClientState(array);
 }
 
 inline void QOpenGLFunctions_1_4::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->EdgeFlagPointer(stride, pointer);
+    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_4::glDisableClientState(GLenum array)
 {
-    d_1_1_Deprecated->DisableClientState(array);
+    d_1_1_Deprecated->f.DisableClientState(array);
 }
 
 inline void QOpenGLFunctions_1_4::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->ColorPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_4::glArrayElement(GLint i)
 {
-    d_1_1_Deprecated->ArrayElement(i);
+    d_1_1_Deprecated->f.ArrayElement(i);
 }
 
 
 // OpenGL 1.2 deprecated functions
 inline void QOpenGLFunctions_1_4::glResetMinmax(GLenum target)
 {
-    d_1_2_Deprecated->ResetMinmax(target);
+    d_1_2_Deprecated->f.ResetMinmax(target);
 }
 
 inline void QOpenGLFunctions_1_4::glResetHistogram(GLenum target)
 {
-    d_1_2_Deprecated->ResetHistogram(target);
+    d_1_2_Deprecated->f.ResetHistogram(target);
 }
 
 inline void QOpenGLFunctions_1_4::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Minmax(target, internalformat, sink);
+    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_1_4::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Histogram(target, width, internalformat, sink);
+    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_1_4::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetMinmax(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_1_4::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetHistogramParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetHistogramParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetHistogram(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_1_4::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
 {
-    d_1_2_Deprecated->SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
+    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
 }
 
 inline void QOpenGLFunctions_1_4::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
 {
-    d_1_2_Deprecated->GetSeparableFilter(target, format, type, row, column, span);
+    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
 }
 
 inline void QOpenGLFunctions_1_4::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
 {
-    d_1_2_Deprecated->GetConvolutionFilter(target, format, type, image);
+    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
 }
 
 inline void QOpenGLFunctions_1_4::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
+    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_4::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter1D(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_4::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
 {
-    d_1_2_Deprecated->ConvolutionParameteri(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
 {
-    d_1_2_Deprecated->ConvolutionParameterf(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
 }
 
 inline void QOpenGLFunctions_1_4::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter1D(target, internalformat, width, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
 }
 
 inline void QOpenGLFunctions_1_4::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorSubTable(target, start, x, y, width);
+    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_4::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
 {
-    d_1_2_Deprecated->ColorSubTable(target, start, count, format, type, data);
+    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
 }
 
 inline void QOpenGLFunctions_1_4::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
 {
-    d_1_2_Deprecated->GetColorTable(target, format, type, table);
+    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
 }
 
 inline void QOpenGLFunctions_1_4::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorTable(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_4::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_4::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
 {
-    d_1_2_Deprecated->ColorTable(target, internalformat, width, format, type, table);
+    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
 }
 
 
 // OpenGL 1.3 deprecated functions
 inline void QOpenGLFunctions_1_4::glMultTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixd(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_4::glMultTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixf(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_4::glLoadTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixd(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_4::glLoadTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixf(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord4sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_3_Deprecated->MultiTexCoord4s(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord4iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_3_Deprecated->MultiTexCoord4i(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_3_Deprecated->MultiTexCoord4f(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_3_Deprecated->MultiTexCoord4d(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord3sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
 {
-    d_1_3_Deprecated->MultiTexCoord3s(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord3iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
 {
-    d_1_3_Deprecated->MultiTexCoord3i(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_3_Deprecated->MultiTexCoord3f(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_3_Deprecated->MultiTexCoord3d(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord2sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
 {
-    d_1_3_Deprecated->MultiTexCoord2s(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord2iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
 {
-    d_1_3_Deprecated->MultiTexCoord2i(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
 {
-    d_1_3_Deprecated->MultiTexCoord2f(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
 {
-    d_1_3_Deprecated->MultiTexCoord2d(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord1sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord1s(GLenum target, GLshort s)
 {
-    d_1_3_Deprecated->MultiTexCoord1s(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord1iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord1i(GLenum target, GLint s)
 {
-    d_1_3_Deprecated->MultiTexCoord1i(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord1f(GLenum target, GLfloat s)
 {
-    d_1_3_Deprecated->MultiTexCoord1f(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
 }
 
 inline void QOpenGLFunctions_1_4::glMultiTexCoord1d(GLenum target, GLdouble s)
 {
-    d_1_3_Deprecated->MultiTexCoord1d(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
 }
 
 inline void QOpenGLFunctions_1_4::glClientActiveTexture(GLenum texture)
 {
-    d_1_3_Deprecated->ClientActiveTexture(texture);
+    d_1_3_Deprecated->f.ClientActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 deprecated functions
 inline void QOpenGLFunctions_1_4::glWindowPos3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos3sv(v);
+    d_1_4_Deprecated->f.WindowPos3sv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glWindowPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_4_Deprecated->WindowPos3s(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glWindowPos3iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos3iv(v);
+    d_1_4_Deprecated->f.WindowPos3iv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glWindowPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_4_Deprecated->WindowPos3i(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glWindowPos3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos3fv(v);
+    d_1_4_Deprecated->f.WindowPos3fv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_4_Deprecated->WindowPos3f(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glWindowPos3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos3dv(v);
+    d_1_4_Deprecated->f.WindowPos3dv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_4_Deprecated->WindowPos3d(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_4::glWindowPos2sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos2sv(v);
+    d_1_4_Deprecated->f.WindowPos2sv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glWindowPos2s(GLshort x, GLshort y)
 {
-    d_1_4_Deprecated->WindowPos2s(x, y);
+    d_1_4_Deprecated->f.WindowPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_1_4::glWindowPos2iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos2iv(v);
+    d_1_4_Deprecated->f.WindowPos2iv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glWindowPos2i(GLint x, GLint y)
 {
-    d_1_4_Deprecated->WindowPos2i(x, y);
+    d_1_4_Deprecated->f.WindowPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_1_4::glWindowPos2fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos2fv(v);
+    d_1_4_Deprecated->f.WindowPos2fv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glWindowPos2f(GLfloat x, GLfloat y)
 {
-    d_1_4_Deprecated->WindowPos2f(x, y);
+    d_1_4_Deprecated->f.WindowPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_1_4::glWindowPos2dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos2dv(v);
+    d_1_4_Deprecated->f.WindowPos2dv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glWindowPos2d(GLdouble x, GLdouble y)
 {
-    d_1_4_Deprecated->WindowPos2d(x, y);
+    d_1_4_Deprecated->f.WindowPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->SecondaryColorPointer(size, type, stride, pointer);
+    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColor3usv(const GLushort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3usv(v);
+    d_1_4_Deprecated->f.SecondaryColor3usv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3us(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColor3uiv(const GLuint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3uiv(v);
+    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ui(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColor3ubv(const GLubyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3ubv(v);
+    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ub(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColor3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3sv(v);
+    d_1_4_Deprecated->f.SecondaryColor3sv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3s(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColor3iv(const GLint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3iv(v);
+    d_1_4_Deprecated->f.SecondaryColor3iv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3i(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColor3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->SecondaryColor3fv(v);
+    d_1_4_Deprecated->f.SecondaryColor3fv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_4_Deprecated->SecondaryColor3f(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColor3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->SecondaryColor3dv(v);
+    d_1_4_Deprecated->f.SecondaryColor3dv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_4_Deprecated->SecondaryColor3d(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColor3bv(const GLbyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3bv(v);
+    d_1_4_Deprecated->f.SecondaryColor3bv(v);
 }
 
 inline void QOpenGLFunctions_1_4::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3b(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_4::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->FogCoordPointer(type, stride, pointer);
+    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_4::glFogCoorddv(const GLdouble *coord)
 {
-    d_1_4_Deprecated->FogCoorddv(coord);
+    d_1_4_Deprecated->f.FogCoorddv(coord);
 }
 
 inline void QOpenGLFunctions_1_4::glFogCoordd(GLdouble coord)
 {
-    d_1_4_Deprecated->FogCoordd(coord);
+    d_1_4_Deprecated->f.FogCoordd(coord);
 }
 
 inline void QOpenGLFunctions_1_4::glFogCoordfv(const GLfloat *coord)
 {
-    d_1_4_Deprecated->FogCoordfv(coord);
+    d_1_4_Deprecated->f.FogCoordfv(coord);
 }
 
 inline void QOpenGLFunctions_1_4::glFogCoordf(GLfloat coord)
 {
-    d_1_4_Deprecated->FogCoordf(coord);
+    d_1_4_Deprecated->f.FogCoordf(coord);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_1_5.cpp b/src/gui/opengl/qopenglfunctions_1_5.cpp
index b0cf705dc49..d07f1decec7 100644
--- a/src/gui/opengl/qopenglfunctions_1_5.cpp
+++ b/src/gui/opengl/qopenglfunctions_1_5.cpp
@@ -83,50 +83,39 @@ QOpenGLFunctions_1_5::QOpenGLFunctions_1_5()
 
 QOpenGLFunctions_1_5::~QOpenGLFunctions_1_5()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
-    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        delete d_1_1_Deprecated;
-    }
-    if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        delete d_1_2_Deprecated;
-    }
-    if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        delete d_1_3_Deprecated;
-    }
-    if (d_1_4_Deprecated && !d_1_4_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        delete d_1_4_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
+    if (d_1_1_Deprecated)
+        d_1_1_Deprecated->refs.deref();
+    Q_ASSERT(d_1_1_Deprecated->refs.load());
+    if (d_1_2_Deprecated)
+        d_1_2_Deprecated->refs.deref();
+    Q_ASSERT(d_1_2_Deprecated->refs.load());
+    if (d_1_3_Deprecated)
+        d_1_3_Deprecated->refs.deref();
+    Q_ASSERT(d_1_3_Deprecated->refs.load());
+    if (d_1_4_Deprecated)
+        d_1_4_Deprecated->refs.deref();
+    Q_ASSERT(d_1_4_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_1_5::initializeOpenGLFunctions()
@@ -145,90 +134,46 @@ bool QOpenGLFunctions_1_5::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_1_5.h b/src/gui/opengl/qopenglfunctions_1_5.h
index 00fd33cea47..d5f23c146be 100644
--- a/src/gui/opengl/qopenglfunctions_1_5.h
+++ b/src/gui/opengl/qopenglfunctions_1_5.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -596,2442 +597,2442 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_1_5::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_5::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_1_5::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_1_5::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_1_5::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_1_5::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_1_5::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_1_5::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_5::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_1_5::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_1_5::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_1_5::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_1_5::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_1_5::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_1_5::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_1_5::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_1_5::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_1_5::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_1_5::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_1_5::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_5::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_1_5::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_1_5::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_1_5::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_5::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_1_5::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_1_5::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_5::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_5::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_5::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_1_5::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_1_5::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_1_5::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_1_5::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_1_5::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline void QOpenGLFunctions_1_5::glIndexubv(const GLubyte *c)
 {
-    d_1_1_Deprecated->Indexubv(c);
+    d_1_1_Deprecated->f.Indexubv(c);
 }
 
 inline void QOpenGLFunctions_1_5::glIndexub(GLubyte c)
 {
-    d_1_1_Deprecated->Indexub(c);
+    d_1_1_Deprecated->f.Indexub(c);
 }
 
 inline GLboolean QOpenGLFunctions_1_5::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_1_5::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_1_5::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_1_5::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_1_5::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_5::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_5::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_5::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_5::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_1_5::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_1_5::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_1_5::glGetPointerv(GLenum pname, GLvoid* *params)
 {
-    d_1_1_Deprecated->GetPointerv(pname, params);
+    d_1_1_Deprecated->f.GetPointerv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_1_5::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_1_5::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_5::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_5::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_5::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_1_5::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_1_5::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_1_5::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_1_5::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_5::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_5::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_5::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_5::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_5::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_1_5::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_1_5::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_1_5::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_1_5::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_1_5::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_1_5::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_1_5::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_1_5::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_1_5::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_1_5::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_1_5::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_1_5::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_1_5::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_1_5::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_1_5::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_1_5::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_1_5::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_1_5::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_1_5::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_1_5::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_1_5::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_1_5::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_1_5::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_5::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_5::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_1_5::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_5::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_5::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_1_5::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_1_5::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_1_5::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_1_5::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_1_5::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_1_5::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_1_5::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_5::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_5::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_1_5::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_1_5::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_1_5::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_1_5::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_5::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_5::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_1_5::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_1_5::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_1_5::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_1_5::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_1_5::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_1_5::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_1_5::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_1_5::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_1_5::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_1_5::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_1_5::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_1_5::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_1_5::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_1_5::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_1_5::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_1_5::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_1_5::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_1_5::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_1_5::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_1_5::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_1_5::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_1_5::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_1_5::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_1_5::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_1_5::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_1_5::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_1_5::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_1_5::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_5::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_1_5::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_1_5::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_1_5::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_1_5::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_1_5::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_1_5::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_1_5::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_1_5::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_1_5::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_1_5::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_1_5::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_1_5::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_1_5::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_1_5::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_5::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_5::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_5::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_5::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_5::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_5::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_1_5::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_1_5::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_5::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_5::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_5::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_5::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_1_5::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_1_5::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_1_5::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_1_5::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_1_5::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_1_5::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_1_5::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_1_5::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_1_5::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_1_5::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_1_5::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_1_5::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_5::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_5::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_5::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_5::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_5::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_5::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_5::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_1_5::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_5::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_5::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_5::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_5::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_5::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_5::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_5::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_5::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_1_5::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_1_5::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_1_5::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_1_5::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_1_5::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_1_5::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_1_5::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_1_5::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
 // OpenGL 1.1 deprecated functions
 inline void QOpenGLFunctions_1_5::glPushClientAttrib(GLbitfield mask)
 {
-    d_1_1_Deprecated->PushClientAttrib(mask);
+    d_1_1_Deprecated->f.PushClientAttrib(mask);
 }
 
 inline void QOpenGLFunctions_1_5::glPopClientAttrib()
 {
-    d_1_1_Deprecated->PopClientAttrib();
+    d_1_1_Deprecated->f.PopClientAttrib();
 }
 
 inline void QOpenGLFunctions_1_5::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 {
-    d_1_1_Deprecated->PrioritizeTextures(n, textures, priorities);
+    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
 }
 
 inline GLboolean QOpenGLFunctions_1_5::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-    return d_1_1_Deprecated->AreTexturesResident(n, textures, residences);
+    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
 }
 
 inline void QOpenGLFunctions_1_5::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->VertexPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_5::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->TexCoordPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_5::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->NormalPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_5::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->InterleavedArrays(format, stride, pointer);
+    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_5::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->IndexPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_5::glEnableClientState(GLenum array)
 {
-    d_1_1_Deprecated->EnableClientState(array);
+    d_1_1_Deprecated->f.EnableClientState(array);
 }
 
 inline void QOpenGLFunctions_1_5::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->EdgeFlagPointer(stride, pointer);
+    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_5::glDisableClientState(GLenum array)
 {
-    d_1_1_Deprecated->DisableClientState(array);
+    d_1_1_Deprecated->f.DisableClientState(array);
 }
 
 inline void QOpenGLFunctions_1_5::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->ColorPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_5::glArrayElement(GLint i)
 {
-    d_1_1_Deprecated->ArrayElement(i);
+    d_1_1_Deprecated->f.ArrayElement(i);
 }
 
 
 // OpenGL 1.2 deprecated functions
 inline void QOpenGLFunctions_1_5::glResetMinmax(GLenum target)
 {
-    d_1_2_Deprecated->ResetMinmax(target);
+    d_1_2_Deprecated->f.ResetMinmax(target);
 }
 
 inline void QOpenGLFunctions_1_5::glResetHistogram(GLenum target)
 {
-    d_1_2_Deprecated->ResetHistogram(target);
+    d_1_2_Deprecated->f.ResetHistogram(target);
 }
 
 inline void QOpenGLFunctions_1_5::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Minmax(target, internalformat, sink);
+    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_1_5::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Histogram(target, width, internalformat, sink);
+    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_1_5::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetMinmax(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_1_5::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetHistogramParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetHistogramParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetHistogram(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_1_5::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
 {
-    d_1_2_Deprecated->SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
+    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
 }
 
 inline void QOpenGLFunctions_1_5::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
 {
-    d_1_2_Deprecated->GetSeparableFilter(target, format, type, row, column, span);
+    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
 }
 
 inline void QOpenGLFunctions_1_5::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
 {
-    d_1_2_Deprecated->GetConvolutionFilter(target, format, type, image);
+    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
 }
 
 inline void QOpenGLFunctions_1_5::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
+    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_1_5::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter1D(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_5::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
 {
-    d_1_2_Deprecated->ConvolutionParameteri(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
 {
-    d_1_2_Deprecated->ConvolutionParameterf(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
 }
 
 inline void QOpenGLFunctions_1_5::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter1D(target, internalformat, width, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
 }
 
 inline void QOpenGLFunctions_1_5::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorSubTable(target, start, x, y, width);
+    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_5::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
 {
-    d_1_2_Deprecated->ColorSubTable(target, start, count, format, type, data);
+    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
 }
 
 inline void QOpenGLFunctions_1_5::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
 {
-    d_1_2_Deprecated->GetColorTable(target, format, type, table);
+    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
 }
 
 inline void QOpenGLFunctions_1_5::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorTable(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_1_5::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_1_5::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
 {
-    d_1_2_Deprecated->ColorTable(target, internalformat, width, format, type, table);
+    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
 }
 
 
 // OpenGL 1.3 deprecated functions
 inline void QOpenGLFunctions_1_5::glMultTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixd(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_5::glMultTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixf(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_5::glLoadTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixd(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_1_5::glLoadTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixf(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord4sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_3_Deprecated->MultiTexCoord4s(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord4iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_3_Deprecated->MultiTexCoord4i(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_3_Deprecated->MultiTexCoord4f(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_3_Deprecated->MultiTexCoord4d(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord3sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
 {
-    d_1_3_Deprecated->MultiTexCoord3s(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord3iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
 {
-    d_1_3_Deprecated->MultiTexCoord3i(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_3_Deprecated->MultiTexCoord3f(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_3_Deprecated->MultiTexCoord3d(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord2sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
 {
-    d_1_3_Deprecated->MultiTexCoord2s(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord2iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
 {
-    d_1_3_Deprecated->MultiTexCoord2i(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
 {
-    d_1_3_Deprecated->MultiTexCoord2f(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
 {
-    d_1_3_Deprecated->MultiTexCoord2d(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord1sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord1s(GLenum target, GLshort s)
 {
-    d_1_3_Deprecated->MultiTexCoord1s(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord1iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord1i(GLenum target, GLint s)
 {
-    d_1_3_Deprecated->MultiTexCoord1i(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord1f(GLenum target, GLfloat s)
 {
-    d_1_3_Deprecated->MultiTexCoord1f(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
 }
 
 inline void QOpenGLFunctions_1_5::glMultiTexCoord1d(GLenum target, GLdouble s)
 {
-    d_1_3_Deprecated->MultiTexCoord1d(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
 }
 
 inline void QOpenGLFunctions_1_5::glClientActiveTexture(GLenum texture)
 {
-    d_1_3_Deprecated->ClientActiveTexture(texture);
+    d_1_3_Deprecated->f.ClientActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 deprecated functions
 inline void QOpenGLFunctions_1_5::glWindowPos3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos3sv(v);
+    d_1_4_Deprecated->f.WindowPos3sv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glWindowPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_4_Deprecated->WindowPos3s(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glWindowPos3iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos3iv(v);
+    d_1_4_Deprecated->f.WindowPos3iv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glWindowPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_4_Deprecated->WindowPos3i(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glWindowPos3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos3fv(v);
+    d_1_4_Deprecated->f.WindowPos3fv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_4_Deprecated->WindowPos3f(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glWindowPos3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos3dv(v);
+    d_1_4_Deprecated->f.WindowPos3dv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_4_Deprecated->WindowPos3d(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_1_5::glWindowPos2sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos2sv(v);
+    d_1_4_Deprecated->f.WindowPos2sv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glWindowPos2s(GLshort x, GLshort y)
 {
-    d_1_4_Deprecated->WindowPos2s(x, y);
+    d_1_4_Deprecated->f.WindowPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_1_5::glWindowPos2iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos2iv(v);
+    d_1_4_Deprecated->f.WindowPos2iv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glWindowPos2i(GLint x, GLint y)
 {
-    d_1_4_Deprecated->WindowPos2i(x, y);
+    d_1_4_Deprecated->f.WindowPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_1_5::glWindowPos2fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos2fv(v);
+    d_1_4_Deprecated->f.WindowPos2fv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glWindowPos2f(GLfloat x, GLfloat y)
 {
-    d_1_4_Deprecated->WindowPos2f(x, y);
+    d_1_4_Deprecated->f.WindowPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_1_5::glWindowPos2dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos2dv(v);
+    d_1_4_Deprecated->f.WindowPos2dv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glWindowPos2d(GLdouble x, GLdouble y)
 {
-    d_1_4_Deprecated->WindowPos2d(x, y);
+    d_1_4_Deprecated->f.WindowPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->SecondaryColorPointer(size, type, stride, pointer);
+    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColor3usv(const GLushort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3usv(v);
+    d_1_4_Deprecated->f.SecondaryColor3usv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3us(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColor3uiv(const GLuint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3uiv(v);
+    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ui(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColor3ubv(const GLubyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3ubv(v);
+    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ub(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColor3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3sv(v);
+    d_1_4_Deprecated->f.SecondaryColor3sv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3s(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColor3iv(const GLint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3iv(v);
+    d_1_4_Deprecated->f.SecondaryColor3iv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3i(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColor3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->SecondaryColor3fv(v);
+    d_1_4_Deprecated->f.SecondaryColor3fv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_4_Deprecated->SecondaryColor3f(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColor3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->SecondaryColor3dv(v);
+    d_1_4_Deprecated->f.SecondaryColor3dv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_4_Deprecated->SecondaryColor3d(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColor3bv(const GLbyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3bv(v);
+    d_1_4_Deprecated->f.SecondaryColor3bv(v);
 }
 
 inline void QOpenGLFunctions_1_5::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3b(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_1_5::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->FogCoordPointer(type, stride, pointer);
+    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_1_5::glFogCoorddv(const GLdouble *coord)
 {
-    d_1_4_Deprecated->FogCoorddv(coord);
+    d_1_4_Deprecated->f.FogCoorddv(coord);
 }
 
 inline void QOpenGLFunctions_1_5::glFogCoordd(GLdouble coord)
 {
-    d_1_4_Deprecated->FogCoordd(coord);
+    d_1_4_Deprecated->f.FogCoordd(coord);
 }
 
 inline void QOpenGLFunctions_1_5::glFogCoordfv(const GLfloat *coord)
 {
-    d_1_4_Deprecated->FogCoordfv(coord);
+    d_1_4_Deprecated->f.FogCoordfv(coord);
 }
 
 inline void QOpenGLFunctions_1_5::glFogCoordf(GLfloat coord)
 {
-    d_1_4_Deprecated->FogCoordf(coord);
+    d_1_4_Deprecated->f.FogCoordf(coord);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_2_0.cpp b/src/gui/opengl/qopenglfunctions_2_0.cpp
index 645134a5885..b7dc8ef4588 100644
--- a/src/gui/opengl/qopenglfunctions_2_0.cpp
+++ b/src/gui/opengl/qopenglfunctions_2_0.cpp
@@ -85,54 +85,42 @@ QOpenGLFunctions_2_0::QOpenGLFunctions_2_0()
 
 QOpenGLFunctions_2_0::~QOpenGLFunctions_2_0()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
-    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        delete d_1_1_Deprecated;
-    }
-    if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        delete d_1_2_Deprecated;
-    }
-    if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        delete d_1_3_Deprecated;
-    }
-    if (d_1_4_Deprecated && !d_1_4_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        delete d_1_4_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
+    if (d_1_1_Deprecated)
+        d_1_1_Deprecated->refs.deref();
+    Q_ASSERT(d_1_1_Deprecated->refs.load());
+    if (d_1_2_Deprecated)
+        d_1_2_Deprecated->refs.deref();
+    Q_ASSERT(d_1_2_Deprecated->refs.load());
+    if (d_1_3_Deprecated)
+        d_1_3_Deprecated->refs.deref();
+    Q_ASSERT(d_1_3_Deprecated->refs.load());
+    if (d_1_4_Deprecated)
+        d_1_4_Deprecated->refs.deref();
+    Q_ASSERT(d_1_4_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_2_0::initializeOpenGLFunctions()
@@ -151,98 +139,50 @@ bool QOpenGLFunctions_2_0::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_2_0.h b/src/gui/opengl/qopenglfunctions_2_0.h
index c46aa08a2d4..81b7274a935 100644
--- a/src/gui/opengl/qopenglfunctions_2_0.h
+++ b/src/gui/opengl/qopenglfunctions_2_0.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -695,2729 +696,2729 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_2_0::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_2_0::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_2_0::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_2_0::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_2_0::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_2_0::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_2_0::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_2_0::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_2_0::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_2_0::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_2_0::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_2_0::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_2_0::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_2_0::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_2_0::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_2_0::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_2_0::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_2_0::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_2_0::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_2_0::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_0::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_2_0::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_2_0::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_2_0::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_0::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_2_0::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_2_0::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_2_0::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_2_0::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_2_0::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_2_0::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_2_0::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_2_0::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_2_0::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_2_0::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline void QOpenGLFunctions_2_0::glIndexubv(const GLubyte *c)
 {
-    d_1_1_Deprecated->Indexubv(c);
+    d_1_1_Deprecated->f.Indexubv(c);
 }
 
 inline void QOpenGLFunctions_2_0::glIndexub(GLubyte c)
 {
-    d_1_1_Deprecated->Indexub(c);
+    d_1_1_Deprecated->f.Indexub(c);
 }
 
 inline GLboolean QOpenGLFunctions_2_0::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_2_0::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_2_0::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_2_0::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_2_0::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_2_0::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_2_0::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_2_0::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_2_0::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_2_0::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_2_0::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_2_0::glGetPointerv(GLenum pname, GLvoid* *params)
 {
-    d_1_1_Deprecated->GetPointerv(pname, params);
+    d_1_1_Deprecated->f.GetPointerv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_2_0::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_2_0::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_2_0::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_2_0::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_2_0::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_2_0::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_2_0::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_2_0::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_2_0::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_2_0::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_2_0::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_2_0::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_2_0::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_2_0::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_2_0::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_2_0::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_2_0::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_2_0::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_2_0::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_2_0::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_2_0::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_2_0::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_2_0::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_2_0::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_2_0::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_2_0::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_2_0::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_2_0::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_2_0::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_2_0::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_2_0::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_2_0::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_2_0::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_2_0::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_0::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_2_0::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_2_0::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_2_0::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_2_0::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_2_0::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_2_0::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_2_0::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_2_0::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_2_0::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_2_0::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_2_0::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_2_0::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_2_0::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_2_0::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_2_0::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_2_0::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_2_0::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_2_0::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_2_0::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_2_0::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_2_0::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_2_0::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_2_0::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_2_0::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_2_0::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_2_0::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_2_0::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_2_0::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_2_0::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_2_0::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_2_0::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_2_0::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_2_0::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, obj);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
 }
 
 inline void QOpenGLFunctions_2_0::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_2_0::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_2_0::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_2_0::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_2_0::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_2_0::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_2_0::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_2_0::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_2_0::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_2_0::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_2_0::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_2_0::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_2_0::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_2_0::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_2_0::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_2_0::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_2_0::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_2_0::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_2_0::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_2_0::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_2_0::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_2_0::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_2_0::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_2_0::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_2_0::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_2_0::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_2_0::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_2_0::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_2_0::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_2_0::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_2_0::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_2_0::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_2_0::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_2_0::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_2_0::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_2_0::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_2_0::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_2_0::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_2_0::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_2_0::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_2_0::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_2_0::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_2_0::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_2_0::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_2_0::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_2_0::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_2_0::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_2_0::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_2_0::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_2_0::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_2_0::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_2_0::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_2_0::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_2_0::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_2_0::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_2_0::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_2_0::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_2_0::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_2_0::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_2_0::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_2_0::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_2_0::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_2_0::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_2_0::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_2_0::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_2_0::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_2_0::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_2_0::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_2_0::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_0::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_2_0::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_2_0::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_2_0::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_2_0::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_2_0::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_2_0::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_2_0::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_2_0::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_2_0::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_2_0::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_2_0::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_2_0::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_2_0::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_2_0::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_2_0::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_2_0::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_2_0::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_2_0::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_2_0::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_2_0::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_2_0::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_2_0::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_2_0::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_2_0::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_2_0::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_2_0::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_2_0::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_2_0::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_2_0::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_2_0::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_2_0::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_2_0::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_2_0::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_2_0::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_2_0::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_2_0::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_2_0::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_2_0::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_0::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_0::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_0::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_0::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_0::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_0::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_0::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_0::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_0::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_0::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_0::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_0::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_0::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_0::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_0::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_0::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_2_0::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_2_0::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_2_0::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_2_0::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_2_0::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_2_0::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_2_0::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_2_0::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
 // OpenGL 1.1 deprecated functions
 inline void QOpenGLFunctions_2_0::glPushClientAttrib(GLbitfield mask)
 {
-    d_1_1_Deprecated->PushClientAttrib(mask);
+    d_1_1_Deprecated->f.PushClientAttrib(mask);
 }
 
 inline void QOpenGLFunctions_2_0::glPopClientAttrib()
 {
-    d_1_1_Deprecated->PopClientAttrib();
+    d_1_1_Deprecated->f.PopClientAttrib();
 }
 
 inline void QOpenGLFunctions_2_0::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 {
-    d_1_1_Deprecated->PrioritizeTextures(n, textures, priorities);
+    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
 }
 
 inline GLboolean QOpenGLFunctions_2_0::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-    return d_1_1_Deprecated->AreTexturesResident(n, textures, residences);
+    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->VertexPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_0::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->TexCoordPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_0::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->NormalPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_0::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->InterleavedArrays(format, stride, pointer);
+    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_0::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->IndexPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_0::glEnableClientState(GLenum array)
 {
-    d_1_1_Deprecated->EnableClientState(array);
+    d_1_1_Deprecated->f.EnableClientState(array);
 }
 
 inline void QOpenGLFunctions_2_0::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->EdgeFlagPointer(stride, pointer);
+    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_0::glDisableClientState(GLenum array)
 {
-    d_1_1_Deprecated->DisableClientState(array);
+    d_1_1_Deprecated->f.DisableClientState(array);
 }
 
 inline void QOpenGLFunctions_2_0::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->ColorPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_0::glArrayElement(GLint i)
 {
-    d_1_1_Deprecated->ArrayElement(i);
+    d_1_1_Deprecated->f.ArrayElement(i);
 }
 
 
 // OpenGL 1.2 deprecated functions
 inline void QOpenGLFunctions_2_0::glResetMinmax(GLenum target)
 {
-    d_1_2_Deprecated->ResetMinmax(target);
+    d_1_2_Deprecated->f.ResetMinmax(target);
 }
 
 inline void QOpenGLFunctions_2_0::glResetHistogram(GLenum target)
 {
-    d_1_2_Deprecated->ResetHistogram(target);
+    d_1_2_Deprecated->f.ResetHistogram(target);
 }
 
 inline void QOpenGLFunctions_2_0::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Minmax(target, internalformat, sink);
+    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_2_0::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Histogram(target, width, internalformat, sink);
+    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_2_0::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetMinmax(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_2_0::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetHistogramParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetHistogramParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetHistogram(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_2_0::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
 {
-    d_1_2_Deprecated->SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
+    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
 }
 
 inline void QOpenGLFunctions_2_0::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
 {
-    d_1_2_Deprecated->GetSeparableFilter(target, format, type, row, column, span);
+    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
 }
 
 inline void QOpenGLFunctions_2_0::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
 {
-    d_1_2_Deprecated->GetConvolutionFilter(target, format, type, image);
+    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
 }
 
 inline void QOpenGLFunctions_2_0::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
+    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_2_0::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter1D(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_2_0::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
 {
-    d_1_2_Deprecated->ConvolutionParameteri(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
 {
-    d_1_2_Deprecated->ConvolutionParameterf(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
 }
 
 inline void QOpenGLFunctions_2_0::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter1D(target, internalformat, width, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
 }
 
 inline void QOpenGLFunctions_2_0::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorSubTable(target, start, x, y, width);
+    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
 }
 
 inline void QOpenGLFunctions_2_0::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
 {
-    d_1_2_Deprecated->ColorSubTable(target, start, count, format, type, data);
+    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
 }
 
 inline void QOpenGLFunctions_2_0::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
 {
-    d_1_2_Deprecated->GetColorTable(target, format, type, table);
+    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
 }
 
 inline void QOpenGLFunctions_2_0::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorTable(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_2_0::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_0::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
 {
-    d_1_2_Deprecated->ColorTable(target, internalformat, width, format, type, table);
+    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
 }
 
 
 // OpenGL 1.3 deprecated functions
 inline void QOpenGLFunctions_2_0::glMultTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixd(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_2_0::glMultTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixf(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_2_0::glLoadTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixd(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_2_0::glLoadTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixf(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord4sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_3_Deprecated->MultiTexCoord4s(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord4iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_3_Deprecated->MultiTexCoord4i(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_3_Deprecated->MultiTexCoord4f(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_3_Deprecated->MultiTexCoord4d(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord3sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
 {
-    d_1_3_Deprecated->MultiTexCoord3s(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord3iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
 {
-    d_1_3_Deprecated->MultiTexCoord3i(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_3_Deprecated->MultiTexCoord3f(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_3_Deprecated->MultiTexCoord3d(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord2sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
 {
-    d_1_3_Deprecated->MultiTexCoord2s(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord2iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
 {
-    d_1_3_Deprecated->MultiTexCoord2i(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
 {
-    d_1_3_Deprecated->MultiTexCoord2f(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
 {
-    d_1_3_Deprecated->MultiTexCoord2d(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord1sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord1s(GLenum target, GLshort s)
 {
-    d_1_3_Deprecated->MultiTexCoord1s(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord1iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord1i(GLenum target, GLint s)
 {
-    d_1_3_Deprecated->MultiTexCoord1i(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord1f(GLenum target, GLfloat s)
 {
-    d_1_3_Deprecated->MultiTexCoord1f(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
 }
 
 inline void QOpenGLFunctions_2_0::glMultiTexCoord1d(GLenum target, GLdouble s)
 {
-    d_1_3_Deprecated->MultiTexCoord1d(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
 }
 
 inline void QOpenGLFunctions_2_0::glClientActiveTexture(GLenum texture)
 {
-    d_1_3_Deprecated->ClientActiveTexture(texture);
+    d_1_3_Deprecated->f.ClientActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 deprecated functions
 inline void QOpenGLFunctions_2_0::glWindowPos3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos3sv(v);
+    d_1_4_Deprecated->f.WindowPos3sv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glWindowPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_4_Deprecated->WindowPos3s(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glWindowPos3iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos3iv(v);
+    d_1_4_Deprecated->f.WindowPos3iv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glWindowPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_4_Deprecated->WindowPos3i(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glWindowPos3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos3fv(v);
+    d_1_4_Deprecated->f.WindowPos3fv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_4_Deprecated->WindowPos3f(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glWindowPos3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos3dv(v);
+    d_1_4_Deprecated->f.WindowPos3dv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_4_Deprecated->WindowPos3d(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glWindowPos2sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos2sv(v);
+    d_1_4_Deprecated->f.WindowPos2sv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glWindowPos2s(GLshort x, GLshort y)
 {
-    d_1_4_Deprecated->WindowPos2s(x, y);
+    d_1_4_Deprecated->f.WindowPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_2_0::glWindowPos2iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos2iv(v);
+    d_1_4_Deprecated->f.WindowPos2iv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glWindowPos2i(GLint x, GLint y)
 {
-    d_1_4_Deprecated->WindowPos2i(x, y);
+    d_1_4_Deprecated->f.WindowPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_2_0::glWindowPos2fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos2fv(v);
+    d_1_4_Deprecated->f.WindowPos2fv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glWindowPos2f(GLfloat x, GLfloat y)
 {
-    d_1_4_Deprecated->WindowPos2f(x, y);
+    d_1_4_Deprecated->f.WindowPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_2_0::glWindowPos2dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos2dv(v);
+    d_1_4_Deprecated->f.WindowPos2dv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glWindowPos2d(GLdouble x, GLdouble y)
 {
-    d_1_4_Deprecated->WindowPos2d(x, y);
+    d_1_4_Deprecated->f.WindowPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->SecondaryColorPointer(size, type, stride, pointer);
+    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColor3usv(const GLushort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3usv(v);
+    d_1_4_Deprecated->f.SecondaryColor3usv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3us(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColor3uiv(const GLuint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3uiv(v);
+    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ui(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColor3ubv(const GLubyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3ubv(v);
+    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ub(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColor3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3sv(v);
+    d_1_4_Deprecated->f.SecondaryColor3sv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3s(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColor3iv(const GLint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3iv(v);
+    d_1_4_Deprecated->f.SecondaryColor3iv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3i(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColor3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->SecondaryColor3fv(v);
+    d_1_4_Deprecated->f.SecondaryColor3fv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_4_Deprecated->SecondaryColor3f(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColor3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->SecondaryColor3dv(v);
+    d_1_4_Deprecated->f.SecondaryColor3dv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_4_Deprecated->SecondaryColor3d(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColor3bv(const GLbyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3bv(v);
+    d_1_4_Deprecated->f.SecondaryColor3bv(v);
 }
 
 inline void QOpenGLFunctions_2_0::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3b(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_0::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->FogCoordPointer(type, stride, pointer);
+    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_0::glFogCoorddv(const GLdouble *coord)
 {
-    d_1_4_Deprecated->FogCoorddv(coord);
+    d_1_4_Deprecated->f.FogCoorddv(coord);
 }
 
 inline void QOpenGLFunctions_2_0::glFogCoordd(GLdouble coord)
 {
-    d_1_4_Deprecated->FogCoordd(coord);
+    d_1_4_Deprecated->f.FogCoordd(coord);
 }
 
 inline void QOpenGLFunctions_2_0::glFogCoordfv(const GLfloat *coord)
 {
-    d_1_4_Deprecated->FogCoordfv(coord);
+    d_1_4_Deprecated->f.FogCoordfv(coord);
 }
 
 inline void QOpenGLFunctions_2_0::glFogCoordf(GLfloat coord)
 {
-    d_1_4_Deprecated->FogCoordf(coord);
+    d_1_4_Deprecated->f.FogCoordf(coord);
 }
 
 
@@ -3426,182 +3427,182 @@ inline void QOpenGLFunctions_2_0::glFogCoordf(GLfloat coord)
 // OpenGL 2.0 deprecated functions
 inline void QOpenGLFunctions_2_0::glVertexAttrib4usv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4usv(index, v);
+    d_2_0_Core->f.VertexAttrib4usv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4uiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4uiv(index, v);
+    d_2_0_Core->f.VertexAttrib4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4ubv(index, v);
+    d_2_0_Core->f.VertexAttrib4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4sv(index, v);
+    d_2_0_Core->f.VertexAttrib4sv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4iv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4iv(index, v);
+    d_2_0_Core->f.VertexAttrib4iv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib4fv(index, v);
+    d_2_0_Core->f.VertexAttrib4fv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib4dv(index, v);
+    d_2_0_Core->f.VertexAttrib4dv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4bv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4bv(index, v);
+    d_2_0_Core->f.VertexAttrib4bv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4Nusv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4Nuiv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nubv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
 {
-    d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4Nsv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4Niv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4Niv(index, v);
+    d_2_0_Core->f.VertexAttrib4Niv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nbv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib3sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib3sv(index, v);
+    d_2_0_Core->f.VertexAttrib3sv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
 {
-    d_2_0_Core->VertexAttrib3s(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib3fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib3fv(index, v);
+    d_2_0_Core->f.VertexAttrib3fv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_2_0_Core->VertexAttrib3f(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib3dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib3dv(index, v);
+    d_2_0_Core->f.VertexAttrib3dv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_2_0_Core->VertexAttrib3d(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib2sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib2sv(index, v);
+    d_2_0_Core->f.VertexAttrib2sv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
 {
-    d_2_0_Core->VertexAttrib2s(index, x, y);
+    d_2_0_Core->f.VertexAttrib2s(index, x, y);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib2fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib2fv(index, v);
+    d_2_0_Core->f.VertexAttrib2fv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
 {
-    d_2_0_Core->VertexAttrib2f(index, x, y);
+    d_2_0_Core->f.VertexAttrib2f(index, x, y);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib2dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib2dv(index, v);
+    d_2_0_Core->f.VertexAttrib2dv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_2_0_Core->VertexAttrib2d(index, x, y);
+    d_2_0_Core->f.VertexAttrib2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib1sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib1sv(index, v);
+    d_2_0_Core->f.VertexAttrib1sv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib1s(GLuint index, GLshort x)
 {
-    d_2_0_Core->VertexAttrib1s(index, x);
+    d_2_0_Core->f.VertexAttrib1s(index, x);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib1fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib1fv(index, v);
+    d_2_0_Core->f.VertexAttrib1fv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib1f(GLuint index, GLfloat x)
 {
-    d_2_0_Core->VertexAttrib1f(index, x);
+    d_2_0_Core->f.VertexAttrib1f(index, x);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib1dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib1dv(index, v);
+    d_2_0_Core->f.VertexAttrib1dv(index, v);
 }
 
 inline void QOpenGLFunctions_2_0::glVertexAttrib1d(GLuint index, GLdouble x)
 {
-    d_2_0_Core->VertexAttrib1d(index, x);
+    d_2_0_Core->f.VertexAttrib1d(index, x);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_2_1.cpp b/src/gui/opengl/qopenglfunctions_2_1.cpp
index 37574c7f44e..e756685d10b 100644
--- a/src/gui/opengl/qopenglfunctions_2_1.cpp
+++ b/src/gui/opengl/qopenglfunctions_2_1.cpp
@@ -86,58 +86,45 @@ QOpenGLFunctions_2_1::QOpenGLFunctions_2_1()
 
 QOpenGLFunctions_2_1::~QOpenGLFunctions_2_1()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
-    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        delete d_1_1_Deprecated;
-    }
-    if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        delete d_1_2_Deprecated;
-    }
-    if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        delete d_1_3_Deprecated;
-    }
-    if (d_1_4_Deprecated && !d_1_4_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        delete d_1_4_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
+    if (d_1_1_Deprecated)
+        d_1_1_Deprecated->refs.deref();
+    Q_ASSERT(d_1_1_Deprecated->refs.load());
+    if (d_1_2_Deprecated)
+        d_1_2_Deprecated->refs.deref();
+    Q_ASSERT(d_1_2_Deprecated->refs.load());
+    if (d_1_3_Deprecated)
+        d_1_3_Deprecated->refs.deref();
+    Q_ASSERT(d_1_3_Deprecated->refs.load());
+    if (d_1_4_Deprecated)
+        d_1_4_Deprecated->refs.deref();
+    Q_ASSERT(d_1_4_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_2_1::initializeOpenGLFunctions()
@@ -156,106 +143,54 @@ bool QOpenGLFunctions_2_1::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_2_1.h b/src/gui/opengl/qopenglfunctions_2_1.h
index 750c394f783..7bac5af9da1 100644
--- a/src/gui/opengl/qopenglfunctions_2_1.h
+++ b/src/gui/opengl/qopenglfunctions_2_1.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -706,2761 +707,2761 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_2_1::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_2_1::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_2_1::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_2_1::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_2_1::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_2_1::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_2_1::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_2_1::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_2_1::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_2_1::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_2_1::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_2_1::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_2_1::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_2_1::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_2_1::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_2_1::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_2_1::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_2_1::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_2_1::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_2_1::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_1::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_2_1::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_2_1::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_2_1::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_1::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_2_1::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_2_1::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_2_1::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_2_1::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_2_1::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_2_1::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_2_1::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_2_1::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_2_1::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_2_1::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline void QOpenGLFunctions_2_1::glIndexubv(const GLubyte *c)
 {
-    d_1_1_Deprecated->Indexubv(c);
+    d_1_1_Deprecated->f.Indexubv(c);
 }
 
 inline void QOpenGLFunctions_2_1::glIndexub(GLubyte c)
 {
-    d_1_1_Deprecated->Indexub(c);
+    d_1_1_Deprecated->f.Indexub(c);
 }
 
 inline GLboolean QOpenGLFunctions_2_1::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_2_1::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_2_1::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_2_1::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_2_1::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_2_1::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_2_1::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_2_1::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_2_1::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_2_1::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_2_1::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_2_1::glGetPointerv(GLenum pname, GLvoid* *params)
 {
-    d_1_1_Deprecated->GetPointerv(pname, params);
+    d_1_1_Deprecated->f.GetPointerv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_2_1::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_2_1::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_2_1::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_2_1::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_2_1::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_2_1::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_2_1::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_2_1::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_2_1::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_2_1::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_2_1::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_2_1::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_2_1::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_2_1::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_2_1::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_2_1::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_2_1::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_2_1::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_2_1::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_2_1::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_2_1::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_2_1::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_2_1::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_2_1::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_2_1::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_2_1::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_2_1::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_2_1::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_2_1::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_2_1::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_2_1::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_2_1::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_2_1::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_2_1::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_1::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_2_1::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_2_1::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_2_1::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_2_1::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_2_1::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_2_1::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_2_1::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_2_1::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_2_1::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_2_1::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_2_1::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_2_1::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_2_1::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_2_1::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_2_1::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_2_1::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_2_1::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_2_1::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_2_1::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_2_1::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_2_1::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_2_1::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_2_1::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_2_1::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_2_1::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_2_1::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_2_1::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_2_1::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_2_1::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_2_1::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_2_1::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_2_1::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_2_1::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, obj);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
 }
 
 inline void QOpenGLFunctions_2_1::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_2_1::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_2_1::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_2_1::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_2_1::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_2_1::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_2_1::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_2_1::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_2_1::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_2_1::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_2_1::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_2_1::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_2_1::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_2_1::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_2_1::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_2_1::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_2_1::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_2_1::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_2_1::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_2_1::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_2_1::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_2_1::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_2_1::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_2_1::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_2_1::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_2_1::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_2_1::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_2_1::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_2_1::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_2_1::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_2_1::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_2_1::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_2_1::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_2_1::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_2_1::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_2_1::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_2_1::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_2_1::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_2_1::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_2_1::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_2_1::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_2_1::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_2_1::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_2_1::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_2_1::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_2_1::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_2_1::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_2_1::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_2_1::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_2_1::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_2_1::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_2_1::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_2_1::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_2_1::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_2_1::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_2_1::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_2_1::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_2_1::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_2_1::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_2_1::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_2_1::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_2_1::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_2_1::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_2_1::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_2_1::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_2_1::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_2_1::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_2_1::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_2_1::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_2_1::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_2_1::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_2_1::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_2_1::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_2_1::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_2_1::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_1::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_2_1::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_2_1::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_2_1::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_2_1::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_2_1::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_2_1::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_2_1::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_2_1::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_2_1::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_2_1::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_2_1::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_2_1::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_2_1::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_2_1::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_2_1::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_2_1::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_2_1::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_2_1::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_2_1::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_2_1::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_2_1::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_2_1::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_2_1::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_2_1::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_2_1::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_2_1::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_2_1::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_2_1::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_2_1::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_2_1::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_2_1::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_2_1::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_2_1::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_2_1::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_2_1::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_2_1::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_2_1::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_2_1::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_1::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_1::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_1::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_1::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_1::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_1::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_1::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_2_1::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_1::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_1::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_1::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_1::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_1::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_1::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_1::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_1::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_2_1::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_2_1::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_2_1::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_2_1::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_2_1::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_2_1::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_2_1::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_2_1::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
 // OpenGL 1.1 deprecated functions
 inline void QOpenGLFunctions_2_1::glPushClientAttrib(GLbitfield mask)
 {
-    d_1_1_Deprecated->PushClientAttrib(mask);
+    d_1_1_Deprecated->f.PushClientAttrib(mask);
 }
 
 inline void QOpenGLFunctions_2_1::glPopClientAttrib()
 {
-    d_1_1_Deprecated->PopClientAttrib();
+    d_1_1_Deprecated->f.PopClientAttrib();
 }
 
 inline void QOpenGLFunctions_2_1::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 {
-    d_1_1_Deprecated->PrioritizeTextures(n, textures, priorities);
+    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
 }
 
 inline GLboolean QOpenGLFunctions_2_1::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-    return d_1_1_Deprecated->AreTexturesResident(n, textures, residences);
+    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->VertexPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_1::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->TexCoordPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_1::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->NormalPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_1::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->InterleavedArrays(format, stride, pointer);
+    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_1::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->IndexPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_1::glEnableClientState(GLenum array)
 {
-    d_1_1_Deprecated->EnableClientState(array);
+    d_1_1_Deprecated->f.EnableClientState(array);
 }
 
 inline void QOpenGLFunctions_2_1::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->EdgeFlagPointer(stride, pointer);
+    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_1::glDisableClientState(GLenum array)
 {
-    d_1_1_Deprecated->DisableClientState(array);
+    d_1_1_Deprecated->f.DisableClientState(array);
 }
 
 inline void QOpenGLFunctions_2_1::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->ColorPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_1::glArrayElement(GLint i)
 {
-    d_1_1_Deprecated->ArrayElement(i);
+    d_1_1_Deprecated->f.ArrayElement(i);
 }
 
 
 // OpenGL 1.2 deprecated functions
 inline void QOpenGLFunctions_2_1::glResetMinmax(GLenum target)
 {
-    d_1_2_Deprecated->ResetMinmax(target);
+    d_1_2_Deprecated->f.ResetMinmax(target);
 }
 
 inline void QOpenGLFunctions_2_1::glResetHistogram(GLenum target)
 {
-    d_1_2_Deprecated->ResetHistogram(target);
+    d_1_2_Deprecated->f.ResetHistogram(target);
 }
 
 inline void QOpenGLFunctions_2_1::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Minmax(target, internalformat, sink);
+    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_2_1::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Histogram(target, width, internalformat, sink);
+    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_2_1::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetMinmax(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_2_1::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetHistogramParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetHistogramParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetHistogram(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_2_1::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
 {
-    d_1_2_Deprecated->SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
+    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
 }
 
 inline void QOpenGLFunctions_2_1::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
 {
-    d_1_2_Deprecated->GetSeparableFilter(target, format, type, row, column, span);
+    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
 }
 
 inline void QOpenGLFunctions_2_1::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
 {
-    d_1_2_Deprecated->GetConvolutionFilter(target, format, type, image);
+    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
 }
 
 inline void QOpenGLFunctions_2_1::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
+    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_2_1::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter1D(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_2_1::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
 {
-    d_1_2_Deprecated->ConvolutionParameteri(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
 {
-    d_1_2_Deprecated->ConvolutionParameterf(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
 }
 
 inline void QOpenGLFunctions_2_1::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter1D(target, internalformat, width, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
 }
 
 inline void QOpenGLFunctions_2_1::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorSubTable(target, start, x, y, width);
+    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
 }
 
 inline void QOpenGLFunctions_2_1::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
 {
-    d_1_2_Deprecated->ColorSubTable(target, start, count, format, type, data);
+    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
 }
 
 inline void QOpenGLFunctions_2_1::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
 {
-    d_1_2_Deprecated->GetColorTable(target, format, type, table);
+    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
 }
 
 inline void QOpenGLFunctions_2_1::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorTable(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_2_1::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_2_1::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
 {
-    d_1_2_Deprecated->ColorTable(target, internalformat, width, format, type, table);
+    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
 }
 
 
 // OpenGL 1.3 deprecated functions
 inline void QOpenGLFunctions_2_1::glMultTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixd(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_2_1::glMultTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixf(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_2_1::glLoadTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixd(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_2_1::glLoadTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixf(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord4sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_3_Deprecated->MultiTexCoord4s(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord4iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_3_Deprecated->MultiTexCoord4i(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_3_Deprecated->MultiTexCoord4f(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_3_Deprecated->MultiTexCoord4d(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord3sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
 {
-    d_1_3_Deprecated->MultiTexCoord3s(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord3iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
 {
-    d_1_3_Deprecated->MultiTexCoord3i(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_3_Deprecated->MultiTexCoord3f(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_3_Deprecated->MultiTexCoord3d(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord2sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
 {
-    d_1_3_Deprecated->MultiTexCoord2s(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord2iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
 {
-    d_1_3_Deprecated->MultiTexCoord2i(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
 {
-    d_1_3_Deprecated->MultiTexCoord2f(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
 {
-    d_1_3_Deprecated->MultiTexCoord2d(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord1sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord1s(GLenum target, GLshort s)
 {
-    d_1_3_Deprecated->MultiTexCoord1s(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord1iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord1i(GLenum target, GLint s)
 {
-    d_1_3_Deprecated->MultiTexCoord1i(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord1f(GLenum target, GLfloat s)
 {
-    d_1_3_Deprecated->MultiTexCoord1f(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
 }
 
 inline void QOpenGLFunctions_2_1::glMultiTexCoord1d(GLenum target, GLdouble s)
 {
-    d_1_3_Deprecated->MultiTexCoord1d(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
 }
 
 inline void QOpenGLFunctions_2_1::glClientActiveTexture(GLenum texture)
 {
-    d_1_3_Deprecated->ClientActiveTexture(texture);
+    d_1_3_Deprecated->f.ClientActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 deprecated functions
 inline void QOpenGLFunctions_2_1::glWindowPos3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos3sv(v);
+    d_1_4_Deprecated->f.WindowPos3sv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glWindowPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_4_Deprecated->WindowPos3s(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glWindowPos3iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos3iv(v);
+    d_1_4_Deprecated->f.WindowPos3iv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glWindowPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_4_Deprecated->WindowPos3i(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glWindowPos3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos3fv(v);
+    d_1_4_Deprecated->f.WindowPos3fv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_4_Deprecated->WindowPos3f(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glWindowPos3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos3dv(v);
+    d_1_4_Deprecated->f.WindowPos3dv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_4_Deprecated->WindowPos3d(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glWindowPos2sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos2sv(v);
+    d_1_4_Deprecated->f.WindowPos2sv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glWindowPos2s(GLshort x, GLshort y)
 {
-    d_1_4_Deprecated->WindowPos2s(x, y);
+    d_1_4_Deprecated->f.WindowPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_2_1::glWindowPos2iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos2iv(v);
+    d_1_4_Deprecated->f.WindowPos2iv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glWindowPos2i(GLint x, GLint y)
 {
-    d_1_4_Deprecated->WindowPos2i(x, y);
+    d_1_4_Deprecated->f.WindowPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_2_1::glWindowPos2fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos2fv(v);
+    d_1_4_Deprecated->f.WindowPos2fv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glWindowPos2f(GLfloat x, GLfloat y)
 {
-    d_1_4_Deprecated->WindowPos2f(x, y);
+    d_1_4_Deprecated->f.WindowPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_2_1::glWindowPos2dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos2dv(v);
+    d_1_4_Deprecated->f.WindowPos2dv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glWindowPos2d(GLdouble x, GLdouble y)
 {
-    d_1_4_Deprecated->WindowPos2d(x, y);
+    d_1_4_Deprecated->f.WindowPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->SecondaryColorPointer(size, type, stride, pointer);
+    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColor3usv(const GLushort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3usv(v);
+    d_1_4_Deprecated->f.SecondaryColor3usv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3us(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColor3uiv(const GLuint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3uiv(v);
+    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ui(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColor3ubv(const GLubyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3ubv(v);
+    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ub(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColor3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3sv(v);
+    d_1_4_Deprecated->f.SecondaryColor3sv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3s(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColor3iv(const GLint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3iv(v);
+    d_1_4_Deprecated->f.SecondaryColor3iv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3i(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColor3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->SecondaryColor3fv(v);
+    d_1_4_Deprecated->f.SecondaryColor3fv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_4_Deprecated->SecondaryColor3f(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColor3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->SecondaryColor3dv(v);
+    d_1_4_Deprecated->f.SecondaryColor3dv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_4_Deprecated->SecondaryColor3d(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColor3bv(const GLbyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3bv(v);
+    d_1_4_Deprecated->f.SecondaryColor3bv(v);
 }
 
 inline void QOpenGLFunctions_2_1::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3b(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_2_1::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->FogCoordPointer(type, stride, pointer);
+    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_2_1::glFogCoorddv(const GLdouble *coord)
 {
-    d_1_4_Deprecated->FogCoorddv(coord);
+    d_1_4_Deprecated->f.FogCoorddv(coord);
 }
 
 inline void QOpenGLFunctions_2_1::glFogCoordd(GLdouble coord)
 {
-    d_1_4_Deprecated->FogCoordd(coord);
+    d_1_4_Deprecated->f.FogCoordd(coord);
 }
 
 inline void QOpenGLFunctions_2_1::glFogCoordfv(const GLfloat *coord)
 {
-    d_1_4_Deprecated->FogCoordfv(coord);
+    d_1_4_Deprecated->f.FogCoordfv(coord);
 }
 
 inline void QOpenGLFunctions_2_1::glFogCoordf(GLfloat coord)
 {
-    d_1_4_Deprecated->FogCoordf(coord);
+    d_1_4_Deprecated->f.FogCoordf(coord);
 }
 
 
@@ -3469,182 +3470,182 @@ inline void QOpenGLFunctions_2_1::glFogCoordf(GLfloat coord)
 // OpenGL 2.0 deprecated functions
 inline void QOpenGLFunctions_2_1::glVertexAttrib4usv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4usv(index, v);
+    d_2_0_Core->f.VertexAttrib4usv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4uiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4uiv(index, v);
+    d_2_0_Core->f.VertexAttrib4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4ubv(index, v);
+    d_2_0_Core->f.VertexAttrib4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4sv(index, v);
+    d_2_0_Core->f.VertexAttrib4sv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4iv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4iv(index, v);
+    d_2_0_Core->f.VertexAttrib4iv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib4fv(index, v);
+    d_2_0_Core->f.VertexAttrib4fv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib4dv(index, v);
+    d_2_0_Core->f.VertexAttrib4dv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4bv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4bv(index, v);
+    d_2_0_Core->f.VertexAttrib4bv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4Nusv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4Nuiv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nubv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
 {
-    d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4Nsv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4Niv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4Niv(index, v);
+    d_2_0_Core->f.VertexAttrib4Niv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nbv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib3sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib3sv(index, v);
+    d_2_0_Core->f.VertexAttrib3sv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
 {
-    d_2_0_Core->VertexAttrib3s(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib3fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib3fv(index, v);
+    d_2_0_Core->f.VertexAttrib3fv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_2_0_Core->VertexAttrib3f(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib3dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib3dv(index, v);
+    d_2_0_Core->f.VertexAttrib3dv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_2_0_Core->VertexAttrib3d(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib2sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib2sv(index, v);
+    d_2_0_Core->f.VertexAttrib2sv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
 {
-    d_2_0_Core->VertexAttrib2s(index, x, y);
+    d_2_0_Core->f.VertexAttrib2s(index, x, y);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib2fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib2fv(index, v);
+    d_2_0_Core->f.VertexAttrib2fv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
 {
-    d_2_0_Core->VertexAttrib2f(index, x, y);
+    d_2_0_Core->f.VertexAttrib2f(index, x, y);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib2dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib2dv(index, v);
+    d_2_0_Core->f.VertexAttrib2dv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_2_0_Core->VertexAttrib2d(index, x, y);
+    d_2_0_Core->f.VertexAttrib2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib1sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib1sv(index, v);
+    d_2_0_Core->f.VertexAttrib1sv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib1s(GLuint index, GLshort x)
 {
-    d_2_0_Core->VertexAttrib1s(index, x);
+    d_2_0_Core->f.VertexAttrib1s(index, x);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib1fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib1fv(index, v);
+    d_2_0_Core->f.VertexAttrib1fv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib1f(GLuint index, GLfloat x)
 {
-    d_2_0_Core->VertexAttrib1f(index, x);
+    d_2_0_Core->f.VertexAttrib1f(index, x);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib1dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib1dv(index, v);
+    d_2_0_Core->f.VertexAttrib1dv(index, v);
 }
 
 inline void QOpenGLFunctions_2_1::glVertexAttrib1d(GLuint index, GLdouble x)
 {
-    d_2_0_Core->VertexAttrib1d(index, x);
+    d_2_0_Core->f.VertexAttrib1d(index, x);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_3_0.cpp b/src/gui/opengl/qopenglfunctions_3_0.cpp
index 7b7a0f1011e..ee7f92855d7 100644
--- a/src/gui/opengl/qopenglfunctions_3_0.cpp
+++ b/src/gui/opengl/qopenglfunctions_3_0.cpp
@@ -88,62 +88,48 @@ QOpenGLFunctions_3_0::QOpenGLFunctions_3_0()
 
 QOpenGLFunctions_3_0::~QOpenGLFunctions_3_0()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
-    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        delete d_1_1_Deprecated;
-    }
-    if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        delete d_1_2_Deprecated;
-    }
-    if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        delete d_1_3_Deprecated;
-    }
-    if (d_1_4_Deprecated && !d_1_4_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        delete d_1_4_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
+    if (d_1_1_Deprecated)
+        d_1_1_Deprecated->refs.deref();
+    Q_ASSERT(d_1_1_Deprecated->refs.load());
+    if (d_1_2_Deprecated)
+        d_1_2_Deprecated->refs.deref();
+    Q_ASSERT(d_1_2_Deprecated->refs.load());
+    if (d_1_3_Deprecated)
+        d_1_3_Deprecated->refs.deref();
+    Q_ASSERT(d_1_3_Deprecated->refs.load());
+    if (d_1_4_Deprecated)
+        d_1_4_Deprecated->refs.deref();
+    Q_ASSERT(d_1_4_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_3_0::initializeOpenGLFunctions()
@@ -162,114 +148,58 @@ bool QOpenGLFunctions_3_0::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_3_0.h b/src/gui/opengl/qopenglfunctions_3_0.h
index 9aa3c8aed54..da8d5ec5ff9 100644
--- a/src/gui/opengl/qopenglfunctions_3_0.h
+++ b/src/gui/opengl/qopenglfunctions_3_0.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -796,3083 +797,3083 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_3_0::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_0::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_3_0::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_3_0::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_3_0::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_3_0::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_3_0::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_3_0::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_0::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_3_0::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_3_0::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_3_0::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_3_0::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_3_0::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_3_0::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_3_0::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_3_0::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_3_0::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_3_0::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_3_0::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_0::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_3_0::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_3_0::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_3_0::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_0::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_3_0::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_3_0::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_0::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_0::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_0::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_3_0::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_3_0::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_3_0::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_3_0::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_3_0::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline void QOpenGLFunctions_3_0::glIndexubv(const GLubyte *c)
 {
-    d_1_1_Deprecated->Indexubv(c);
+    d_1_1_Deprecated->f.Indexubv(c);
 }
 
 inline void QOpenGLFunctions_3_0::glIndexub(GLubyte c)
 {
-    d_1_1_Deprecated->Indexub(c);
+    d_1_1_Deprecated->f.Indexub(c);
 }
 
 inline GLboolean QOpenGLFunctions_3_0::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_3_0::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_3_0::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_3_0::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_3_0::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_0::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_0::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_0::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_3_0::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_3_0::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_3_0::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_3_0::glGetPointerv(GLenum pname, GLvoid* *params)
 {
-    d_1_1_Deprecated->GetPointerv(pname, params);
+    d_1_1_Deprecated->f.GetPointerv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_3_0::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_3_0::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_0::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_0::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_0::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_3_0::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_3_0::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_3_0::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_3_0::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_0::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_0::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_0::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_0::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_0::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_0::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_3_0::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_3_0::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_3_0::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_3_0::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_3_0::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_3_0::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_3_0::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_3_0::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_3_0::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_3_0::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_3_0::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_3_0::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_3_0::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_3_0::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_3_0::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_3_0::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_3_0::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_3_0::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_3_0::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_0::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_3_0::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_3_0::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_3_0::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_3_0::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_3_0::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_3_0::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_3_0::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_3_0::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_3_0::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_0::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_3_0::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_3_0::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_3_0::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_3_0::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_0::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, obj);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
 }
 
 inline void QOpenGLFunctions_3_0::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_0::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_0::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_3_0::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_3_0::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_3_0::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_3_0::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_3_0::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_3_0::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_3_0::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_3_0::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_3_0::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_3_0::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_3_0::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_3_0::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_3_0::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_3_0::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_3_0::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_3_0::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_3_0::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_3_0::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_3_0::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_3_0::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline GLvoid* QOpenGLFunctions_3_0::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_3_0::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_3_0::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_3_0::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_3_0::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_3_0::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_3_0::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_3_0::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_3_0::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_3_0::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_3_0::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_3_0::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_3_0::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_3_0::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_3_0::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_3_0::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_3_0::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_3_0::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_3_0::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_3_0::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_3_0::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_3_0::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_0::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_0::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_0::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_0::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_3_0::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_0::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_3_0::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_0::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_3_0::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_3_0::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_3_0::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_0::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_3_0::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_3_0::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_3_0::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_3_0::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_3_0::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_3_0::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_3_0::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_3_0::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_3_0::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_3_0::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_3_0::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_3_0::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_3_0::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_3_0::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_3_0::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_3_0::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_3_0::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_3_0::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_3_0::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_3_0::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_3_0::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_3_0::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_3_0::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_3_0::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_3_0::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_3_0::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_3_0::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_3_0::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_3_0::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_3_0::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_0::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_3_0::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_3_0::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_3_0::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_3_0::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_3_0::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_3_0::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_3_0::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_3_0::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_3_0::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_3_0::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_3_0::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_3_0::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_3_0::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_3_0::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_3_0::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_3_0::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_3_0::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_3_0::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_0::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_0::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_3_0::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_3_0::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_3_0::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_3_0::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_3_0::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_3_0::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_3_0::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_3_0::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_3_0::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_3_0::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_3_0::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_0::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_3_0::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_3_0::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_3_0::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_3_0::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_3_0::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_3_0::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_3_0::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_3_0::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_3_0::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_3_0::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_3_0::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_3_0::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_3_0::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_3_0::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_3_0::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_3_0::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_3_0::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_3_0::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_3_0::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_3_0::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_3_0::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_3_0::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_3_0::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_3_0::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_3_0::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_3_0::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_3_0::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_3_0::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_3_0::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_3_0::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_3_0::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_3_0::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_3_0::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_3_0::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_3_0::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_3_0::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_3_0::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_0::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_0::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_0::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_0::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_0::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_0::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_0::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_0::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_0::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_0::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_0::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_0::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_0::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_0::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_0::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_0::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_3_0::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_3_0::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_3_0::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_3_0::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_3_0::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_3_0::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_3_0::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_3_0::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
 // OpenGL 1.1 deprecated functions
 inline void QOpenGLFunctions_3_0::glPushClientAttrib(GLbitfield mask)
 {
-    d_1_1_Deprecated->PushClientAttrib(mask);
+    d_1_1_Deprecated->f.PushClientAttrib(mask);
 }
 
 inline void QOpenGLFunctions_3_0::glPopClientAttrib()
 {
-    d_1_1_Deprecated->PopClientAttrib();
+    d_1_1_Deprecated->f.PopClientAttrib();
 }
 
 inline void QOpenGLFunctions_3_0::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 {
-    d_1_1_Deprecated->PrioritizeTextures(n, textures, priorities);
+    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
 }
 
 inline GLboolean QOpenGLFunctions_3_0::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-    return d_1_1_Deprecated->AreTexturesResident(n, textures, residences);
+    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->VertexPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_0::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->TexCoordPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_0::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->NormalPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_0::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->InterleavedArrays(format, stride, pointer);
+    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_0::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->IndexPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_0::glEnableClientState(GLenum array)
 {
-    d_1_1_Deprecated->EnableClientState(array);
+    d_1_1_Deprecated->f.EnableClientState(array);
 }
 
 inline void QOpenGLFunctions_3_0::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->EdgeFlagPointer(stride, pointer);
+    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_0::glDisableClientState(GLenum array)
 {
-    d_1_1_Deprecated->DisableClientState(array);
+    d_1_1_Deprecated->f.DisableClientState(array);
 }
 
 inline void QOpenGLFunctions_3_0::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->ColorPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_0::glArrayElement(GLint i)
 {
-    d_1_1_Deprecated->ArrayElement(i);
+    d_1_1_Deprecated->f.ArrayElement(i);
 }
 
 
 // OpenGL 1.2 deprecated functions
 inline void QOpenGLFunctions_3_0::glResetMinmax(GLenum target)
 {
-    d_1_2_Deprecated->ResetMinmax(target);
+    d_1_2_Deprecated->f.ResetMinmax(target);
 }
 
 inline void QOpenGLFunctions_3_0::glResetHistogram(GLenum target)
 {
-    d_1_2_Deprecated->ResetHistogram(target);
+    d_1_2_Deprecated->f.ResetHistogram(target);
 }
 
 inline void QOpenGLFunctions_3_0::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Minmax(target, internalformat, sink);
+    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_3_0::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Histogram(target, width, internalformat, sink);
+    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_3_0::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetMinmax(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_3_0::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetHistogramParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetHistogramParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetHistogram(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_3_0::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
 {
-    d_1_2_Deprecated->SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
+    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
 }
 
 inline void QOpenGLFunctions_3_0::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
 {
-    d_1_2_Deprecated->GetSeparableFilter(target, format, type, row, column, span);
+    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
 }
 
 inline void QOpenGLFunctions_3_0::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
 {
-    d_1_2_Deprecated->GetConvolutionFilter(target, format, type, image);
+    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
 }
 
 inline void QOpenGLFunctions_3_0::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
+    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_0::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter1D(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_3_0::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
 {
-    d_1_2_Deprecated->ConvolutionParameteri(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
 {
-    d_1_2_Deprecated->ConvolutionParameterf(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
 }
 
 inline void QOpenGLFunctions_3_0::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter1D(target, internalformat, width, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
 }
 
 inline void QOpenGLFunctions_3_0::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorSubTable(target, start, x, y, width);
+    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
 }
 
 inline void QOpenGLFunctions_3_0::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
 {
-    d_1_2_Deprecated->ColorSubTable(target, start, count, format, type, data);
+    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
 }
 
 inline void QOpenGLFunctions_3_0::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
 {
-    d_1_2_Deprecated->GetColorTable(target, format, type, table);
+    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
 }
 
 inline void QOpenGLFunctions_3_0::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorTable(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_3_0::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_0::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
 {
-    d_1_2_Deprecated->ColorTable(target, internalformat, width, format, type, table);
+    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
 }
 
 
 // OpenGL 1.3 deprecated functions
 inline void QOpenGLFunctions_3_0::glMultTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixd(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_3_0::glMultTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixf(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_3_0::glLoadTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixd(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_3_0::glLoadTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixf(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord4sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_3_Deprecated->MultiTexCoord4s(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord4iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_3_Deprecated->MultiTexCoord4i(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_3_Deprecated->MultiTexCoord4f(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_3_Deprecated->MultiTexCoord4d(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord3sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
 {
-    d_1_3_Deprecated->MultiTexCoord3s(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord3iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
 {
-    d_1_3_Deprecated->MultiTexCoord3i(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_3_Deprecated->MultiTexCoord3f(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_3_Deprecated->MultiTexCoord3d(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord2sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
 {
-    d_1_3_Deprecated->MultiTexCoord2s(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord2iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
 {
-    d_1_3_Deprecated->MultiTexCoord2i(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
 {
-    d_1_3_Deprecated->MultiTexCoord2f(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
 {
-    d_1_3_Deprecated->MultiTexCoord2d(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord1sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord1s(GLenum target, GLshort s)
 {
-    d_1_3_Deprecated->MultiTexCoord1s(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord1iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord1i(GLenum target, GLint s)
 {
-    d_1_3_Deprecated->MultiTexCoord1i(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord1f(GLenum target, GLfloat s)
 {
-    d_1_3_Deprecated->MultiTexCoord1f(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
 }
 
 inline void QOpenGLFunctions_3_0::glMultiTexCoord1d(GLenum target, GLdouble s)
 {
-    d_1_3_Deprecated->MultiTexCoord1d(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
 }
 
 inline void QOpenGLFunctions_3_0::glClientActiveTexture(GLenum texture)
 {
-    d_1_3_Deprecated->ClientActiveTexture(texture);
+    d_1_3_Deprecated->f.ClientActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 deprecated functions
 inline void QOpenGLFunctions_3_0::glWindowPos3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos3sv(v);
+    d_1_4_Deprecated->f.WindowPos3sv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glWindowPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_4_Deprecated->WindowPos3s(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glWindowPos3iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos3iv(v);
+    d_1_4_Deprecated->f.WindowPos3iv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glWindowPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_4_Deprecated->WindowPos3i(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glWindowPos3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos3fv(v);
+    d_1_4_Deprecated->f.WindowPos3fv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_4_Deprecated->WindowPos3f(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glWindowPos3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos3dv(v);
+    d_1_4_Deprecated->f.WindowPos3dv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_4_Deprecated->WindowPos3d(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glWindowPos2sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos2sv(v);
+    d_1_4_Deprecated->f.WindowPos2sv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glWindowPos2s(GLshort x, GLshort y)
 {
-    d_1_4_Deprecated->WindowPos2s(x, y);
+    d_1_4_Deprecated->f.WindowPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glWindowPos2iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos2iv(v);
+    d_1_4_Deprecated->f.WindowPos2iv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glWindowPos2i(GLint x, GLint y)
 {
-    d_1_4_Deprecated->WindowPos2i(x, y);
+    d_1_4_Deprecated->f.WindowPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glWindowPos2fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos2fv(v);
+    d_1_4_Deprecated->f.WindowPos2fv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glWindowPos2f(GLfloat x, GLfloat y)
 {
-    d_1_4_Deprecated->WindowPos2f(x, y);
+    d_1_4_Deprecated->f.WindowPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glWindowPos2dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos2dv(v);
+    d_1_4_Deprecated->f.WindowPos2dv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glWindowPos2d(GLdouble x, GLdouble y)
 {
-    d_1_4_Deprecated->WindowPos2d(x, y);
+    d_1_4_Deprecated->f.WindowPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->SecondaryColorPointer(size, type, stride, pointer);
+    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColor3usv(const GLushort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3usv(v);
+    d_1_4_Deprecated->f.SecondaryColor3usv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3us(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColor3uiv(const GLuint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3uiv(v);
+    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ui(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColor3ubv(const GLubyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3ubv(v);
+    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ub(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColor3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3sv(v);
+    d_1_4_Deprecated->f.SecondaryColor3sv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3s(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColor3iv(const GLint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3iv(v);
+    d_1_4_Deprecated->f.SecondaryColor3iv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3i(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColor3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->SecondaryColor3fv(v);
+    d_1_4_Deprecated->f.SecondaryColor3fv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_4_Deprecated->SecondaryColor3f(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColor3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->SecondaryColor3dv(v);
+    d_1_4_Deprecated->f.SecondaryColor3dv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_4_Deprecated->SecondaryColor3d(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColor3bv(const GLbyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3bv(v);
+    d_1_4_Deprecated->f.SecondaryColor3bv(v);
 }
 
 inline void QOpenGLFunctions_3_0::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3b(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_0::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->FogCoordPointer(type, stride, pointer);
+    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_0::glFogCoorddv(const GLdouble *coord)
 {
-    d_1_4_Deprecated->FogCoorddv(coord);
+    d_1_4_Deprecated->f.FogCoorddv(coord);
 }
 
 inline void QOpenGLFunctions_3_0::glFogCoordd(GLdouble coord)
 {
-    d_1_4_Deprecated->FogCoordd(coord);
+    d_1_4_Deprecated->f.FogCoordd(coord);
 }
 
 inline void QOpenGLFunctions_3_0::glFogCoordfv(const GLfloat *coord)
 {
-    d_1_4_Deprecated->FogCoordfv(coord);
+    d_1_4_Deprecated->f.FogCoordfv(coord);
 }
 
 inline void QOpenGLFunctions_3_0::glFogCoordf(GLfloat coord)
 {
-    d_1_4_Deprecated->FogCoordf(coord);
+    d_1_4_Deprecated->f.FogCoordf(coord);
 }
 
 
@@ -3881,182 +3882,182 @@ inline void QOpenGLFunctions_3_0::glFogCoordf(GLfloat coord)
 // OpenGL 2.0 deprecated functions
 inline void QOpenGLFunctions_3_0::glVertexAttrib4usv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4usv(index, v);
+    d_2_0_Core->f.VertexAttrib4usv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4uiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4uiv(index, v);
+    d_2_0_Core->f.VertexAttrib4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4ubv(index, v);
+    d_2_0_Core->f.VertexAttrib4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4sv(index, v);
+    d_2_0_Core->f.VertexAttrib4sv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4iv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4iv(index, v);
+    d_2_0_Core->f.VertexAttrib4iv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib4fv(index, v);
+    d_2_0_Core->f.VertexAttrib4fv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib4dv(index, v);
+    d_2_0_Core->f.VertexAttrib4dv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4bv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4bv(index, v);
+    d_2_0_Core->f.VertexAttrib4bv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4Nusv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4Nuiv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nubv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
 {
-    d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4Nsv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4Niv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4Niv(index, v);
+    d_2_0_Core->f.VertexAttrib4Niv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nbv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib3sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib3sv(index, v);
+    d_2_0_Core->f.VertexAttrib3sv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
 {
-    d_2_0_Core->VertexAttrib3s(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib3fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib3fv(index, v);
+    d_2_0_Core->f.VertexAttrib3fv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_2_0_Core->VertexAttrib3f(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib3dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib3dv(index, v);
+    d_2_0_Core->f.VertexAttrib3dv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_2_0_Core->VertexAttrib3d(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib2sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib2sv(index, v);
+    d_2_0_Core->f.VertexAttrib2sv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
 {
-    d_2_0_Core->VertexAttrib2s(index, x, y);
+    d_2_0_Core->f.VertexAttrib2s(index, x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib2fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib2fv(index, v);
+    d_2_0_Core->f.VertexAttrib2fv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
 {
-    d_2_0_Core->VertexAttrib2f(index, x, y);
+    d_2_0_Core->f.VertexAttrib2f(index, x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib2dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib2dv(index, v);
+    d_2_0_Core->f.VertexAttrib2dv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_2_0_Core->VertexAttrib2d(index, x, y);
+    d_2_0_Core->f.VertexAttrib2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib1sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib1sv(index, v);
+    d_2_0_Core->f.VertexAttrib1sv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib1s(GLuint index, GLshort x)
 {
-    d_2_0_Core->VertexAttrib1s(index, x);
+    d_2_0_Core->f.VertexAttrib1s(index, x);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib1fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib1fv(index, v);
+    d_2_0_Core->f.VertexAttrib1fv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib1f(GLuint index, GLfloat x)
 {
-    d_2_0_Core->VertexAttrib1f(index, x);
+    d_2_0_Core->f.VertexAttrib1f(index, x);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib1dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib1dv(index, v);
+    d_2_0_Core->f.VertexAttrib1dv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttrib1d(GLuint index, GLdouble x)
 {
-    d_2_0_Core->VertexAttrib1d(index, x);
+    d_2_0_Core->f.VertexAttrib1d(index, x);
 }
 
 
@@ -4065,102 +4066,102 @@ inline void QOpenGLFunctions_3_0::glVertexAttrib1d(GLuint index, GLdouble x)
 // OpenGL 3.0 deprecated functions
 inline void QOpenGLFunctions_3_0::glVertexAttribI4usv(GLuint index, const GLushort *v)
 {
-    d_3_0_Core->VertexAttribI4usv(index, v);
+    d_3_0_Core->f.VertexAttribI4usv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
 {
-    d_3_0_Core->VertexAttribI4ubv(index, v);
+    d_3_0_Core->f.VertexAttribI4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI4sv(GLuint index, const GLshort *v)
 {
-    d_3_0_Core->VertexAttribI4sv(index, v);
+    d_3_0_Core->f.VertexAttribI4sv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI4bv(GLuint index, const GLbyte *v)
 {
-    d_3_0_Core->VertexAttribI4bv(index, v);
+    d_3_0_Core->f.VertexAttribI4bv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI4uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI4uiv(index, v);
+    d_3_0_Core->f.VertexAttribI4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI3uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI3uiv(index, v);
+    d_3_0_Core->f.VertexAttribI3uiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI2uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI2uiv(index, v);
+    d_3_0_Core->f.VertexAttribI2uiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI1uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI1uiv(index, v);
+    d_3_0_Core->f.VertexAttribI1uiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI4iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI4iv(index, v);
+    d_3_0_Core->f.VertexAttribI4iv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI3iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI3iv(index, v);
+    d_3_0_Core->f.VertexAttribI3iv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI2iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI2iv(index, v);
+    d_3_0_Core->f.VertexAttribI2iv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI1iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI1iv(index, v);
+    d_3_0_Core->f.VertexAttribI1iv(index, v);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
 {
-    d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
 {
-    d_3_0_Core->VertexAttribI3ui(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
 {
-    d_3_0_Core->VertexAttribI2ui(index, x, y);
+    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI1ui(GLuint index, GLuint x)
 {
-    d_3_0_Core->VertexAttribI1ui(index, x);
+    d_3_0_Core->f.VertexAttribI1ui(index, x);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
 {
-    d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
 {
-    d_3_0_Core->VertexAttribI3i(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI2i(GLuint index, GLint x, GLint y)
 {
-    d_3_0_Core->VertexAttribI2i(index, x, y);
+    d_3_0_Core->f.VertexAttribI2i(index, x, y);
 }
 
 inline void QOpenGLFunctions_3_0::glVertexAttribI1i(GLuint index, GLint x)
 {
-    d_3_0_Core->VertexAttribI1i(index, x);
+    d_3_0_Core->f.VertexAttribI1i(index, x);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_3_1.cpp b/src/gui/opengl/qopenglfunctions_3_1.cpp
index b1c16a08d06..a459ddf2442 100644
--- a/src/gui/opengl/qopenglfunctions_3_1.cpp
+++ b/src/gui/opengl/qopenglfunctions_3_1.cpp
@@ -82,46 +82,36 @@ QOpenGLFunctions_3_1::QOpenGLFunctions_3_1()
 
 QOpenGLFunctions_3_1::~QOpenGLFunctions_3_1()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
 }
 
 bool QOpenGLFunctions_3_1::initializeOpenGLFunctions()
@@ -140,82 +130,42 @@ bool QOpenGLFunctions_3_1::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_3_1.h b/src/gui/opengl/qopenglfunctions_3_1.h
index fac9b870ebb..d5957381e9d 100644
--- a/src/gui/opengl/qopenglfunctions_3_1.h
+++ b/src/gui/opengl/qopenglfunctions_3_1.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -351,242 +352,242 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_3_1::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_1::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_3_1::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_3_1::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_3_1::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_3_1::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_3_1::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_3_1::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_1::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_3_1::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_3_1::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_3_1::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_3_1::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_3_1::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_3_1::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_3_1::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_3_1::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_3_1::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_3_1::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_3_1::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_3_1::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_3_1::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_1::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_3_1::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_3_1::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_3_1::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_1::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_3_1::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_3_1::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_1::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_1::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_1::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_1::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_1::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_3_1::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_3_1::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_3_1::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_3_1::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_3_1::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
@@ -605,57 +606,57 @@ inline void QOpenGLFunctions_3_1::glIndexub(GLubyte c)
 
 inline GLboolean QOpenGLFunctions_3_1::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_3_1::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_3_1::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_3_1::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_3_1::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_1::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_1::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_1::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_3_1::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_3_1::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_3_1::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_3_1::glGetPointerv(GLenum pname, GLvoid* *params)
@@ -667,928 +668,928 @@ inline void QOpenGLFunctions_3_1::glGetPointerv(GLenum pname, GLvoid* *params)
 
 inline void QOpenGLFunctions_3_1::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_3_1::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_3_1::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_1::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_1::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_1::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_3_1::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_3_1::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_3_1::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_3_1::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_1::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_1::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_1::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_1::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_1::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_1::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_3_1::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_3_1::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_3_1::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_3_1::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_3_1::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_3_1::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_3_1::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_3_1::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_3_1::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_3_1::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_3_1::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_3_1::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_3_1::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_3_1::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_3_1::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_3_1::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_3_1::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_3_1::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_3_1::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_3_1::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_3_1::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_3_1::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_1::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_3_1::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_3_1::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_3_1::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_3_1::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_3_1::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_3_1::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_3_1::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_3_1::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_3_1::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_1::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_3_1::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_3_1::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_3_1::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_3_1::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_1::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, obj);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
 }
 
 inline void QOpenGLFunctions_3_1::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_1::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_1::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_3_1::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_3_1::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_3_1::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_3_1::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_3_1::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_3_1::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_3_1::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_3_1::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_3_1::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_3_1::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_3_1::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_3_1::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_3_1::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_3_1::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_3_1::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_3_1::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_3_1::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_3_1::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_3_1::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_3_1::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline GLvoid* QOpenGLFunctions_3_1::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_3_1::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_3_1::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_3_1::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_3_1::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_3_1::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_3_1::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_3_1::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_3_1::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_3_1::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_3_1::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_3_1::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_3_1::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_3_1::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_3_1::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_3_1::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_3_1::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_3_1::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_3_1::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_3_1::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_3_1::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_3_1::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_1::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_1::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_1::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_1::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_3_1::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_1::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_3_1::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_1::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_3_1::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_3_1::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_3_1::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_1::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_3_1::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_3_1::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_3_1::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_3_1::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_3_1::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_3_1::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_3_1::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_3_1::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_3_1::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_3_1::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_3_1::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_3_1::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_3_1::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_3_1::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_3_1::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_3_1::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_3_1::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_3_1::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_3_1::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_3_1::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_3_1::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_3_1::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_3_2_compatibility.cpp b/src/gui/opengl/qopenglfunctions_3_2_compatibility.cpp
index e14a01ed055..09402db09ad 100644
--- a/src/gui/opengl/qopenglfunctions_3_2_compatibility.cpp
+++ b/src/gui/opengl/qopenglfunctions_3_2_compatibility.cpp
@@ -90,70 +90,54 @@ QOpenGLFunctions_3_2_Compatibility::QOpenGLFunctions_3_2_Compatibility()
 
 QOpenGLFunctions_3_2_Compatibility::~QOpenGLFunctions_3_2_Compatibility()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
-    if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        delete d_3_2_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
-    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        delete d_1_1_Deprecated;
-    }
-    if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        delete d_1_2_Deprecated;
-    }
-    if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        delete d_1_3_Deprecated;
-    }
-    if (d_1_4_Deprecated && !d_1_4_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        delete d_1_4_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
+    if (d_3_2_Core)
+        d_3_2_Core->refs.deref();
+    Q_ASSERT(d_3_2_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
+    if (d_1_1_Deprecated)
+        d_1_1_Deprecated->refs.deref();
+    Q_ASSERT(d_1_1_Deprecated->refs.load());
+    if (d_1_2_Deprecated)
+        d_1_2_Deprecated->refs.deref();
+    Q_ASSERT(d_1_2_Deprecated->refs.load());
+    if (d_1_3_Deprecated)
+        d_1_3_Deprecated->refs.deref();
+    Q_ASSERT(d_1_3_Deprecated->refs.load());
+    if (d_1_4_Deprecated)
+        d_1_4_Deprecated->refs.deref();
+    Q_ASSERT(d_1_4_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_3_2_Compatibility::initializeOpenGLFunctions()
@@ -172,130 +156,66 @@ bool QOpenGLFunctions_3_2_Compatibility::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
-        }
         d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_3_2_compatibility.h b/src/gui/opengl/qopenglfunctions_3_2_compatibility.h
index 8d9216ac043..44fa6759e53 100644
--- a/src/gui/opengl/qopenglfunctions_3_2_compatibility.h
+++ b/src/gui/opengl/qopenglfunctions_3_2_compatibility.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -837,3242 +838,3242 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_3_2_Compatibility::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_3_2_Compatibility::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_3_2_Compatibility::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline void QOpenGLFunctions_3_2_Compatibility::glIndexubv(const GLubyte *c)
 {
-    d_1_1_Deprecated->Indexubv(c);
+    d_1_1_Deprecated->f.Indexubv(c);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glIndexub(GLubyte c)
 {
-    d_1_1_Deprecated->Indexub(c);
+    d_1_1_Deprecated->f.Indexub(c);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
 {
-    d_1_1_Deprecated->GetPointerv(pname, params);
+    d_1_1_Deprecated->f.GetPointerv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_3_2_Compatibility::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_3_2_Compatibility::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_3_2_Compatibility::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_3_2_Compatibility::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Compatibility::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_3_2_Compatibility::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_3_2_Compatibility::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_3_2_Compatibility::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, obj);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_3_2_Compatibility::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_3_2_Compatibility::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline GLvoid* QOpenGLFunctions_3_2_Compatibility::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_3_2_Compatibility::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_3_2_Compatibility::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_3_2_Compatibility::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_3_2_Compatibility::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_3_2_Compatibility::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
 // OpenGL 3.2 core functions
 inline void QOpenGLFunctions_3_2_Compatibility::glSampleMaski(GLuint index, GLbitfield mask)
 {
-    d_3_2_Core->SampleMaski(index, mask);
+    d_3_2_Core->f.SampleMaski(index, mask);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
 {
-    d_3_2_Core->GetMultisamplefv(pname, index, val);
+    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
-    d_3_2_Core->GetSynciv(sync, pname, bufSize, length, values);
+    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetInteger64v(GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetInteger64v(pname, params);
+    d_3_2_Core->f.GetInteger64v(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    d_3_2_Core->WaitSync(sync, flags, timeout);
+    d_3_2_Core->f.WaitSync(sync, flags, timeout);
 }
 
 inline GLenum QOpenGLFunctions_3_2_Compatibility::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    return d_3_2_Core->ClientWaitSync(sync, flags, timeout);
+    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDeleteSync(GLsync sync)
 {
-    d_3_2_Core->DeleteSync(sync);
+    d_3_2_Core->f.DeleteSync(sync);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsSync(GLsync sync)
 {
-    return d_3_2_Core->IsSync(sync);
+    return d_3_2_Core->f.IsSync(sync);
 }
 
 inline GLsync QOpenGLFunctions_3_2_Compatibility::glFenceSync(GLenum condition, GLbitfield flags)
 {
-    return d_3_2_Core->FenceSync(condition, flags);
+    return d_3_2_Core->f.FenceSync(condition, flags);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glProvokingVertex(GLenum mode)
 {
-    d_3_2_Core->ProvokingVertex(mode);
+    d_3_2_Core->f.ProvokingVertex(mode);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
 {
-    d_3_2_Core->MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
-    d_3_2_Core->FramebufferTexture(target, attachment, texture, level);
+    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetBufferParameteri64v(target, pname, params);
+    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64i_v(target, index, data);
+    d_3_2_Core->f.GetInteger64i_v(target, index, data);
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_3_2_Compatibility::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Compatibility::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_3_2_Compatibility::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_3_2_Compatibility::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
 // OpenGL 1.1 deprecated functions
 inline void QOpenGLFunctions_3_2_Compatibility::glPushClientAttrib(GLbitfield mask)
 {
-    d_1_1_Deprecated->PushClientAttrib(mask);
+    d_1_1_Deprecated->f.PushClientAttrib(mask);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPopClientAttrib()
 {
-    d_1_1_Deprecated->PopClientAttrib();
+    d_1_1_Deprecated->f.PopClientAttrib();
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 {
-    d_1_1_Deprecated->PrioritizeTextures(n, textures, priorities);
+    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Compatibility::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-    return d_1_1_Deprecated->AreTexturesResident(n, textures, residences);
+    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->VertexPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->TexCoordPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->NormalPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->InterleavedArrays(format, stride, pointer);
+    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->IndexPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEnableClientState(GLenum array)
 {
-    d_1_1_Deprecated->EnableClientState(array);
+    d_1_1_Deprecated->f.EnableClientState(array);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->EdgeFlagPointer(stride, pointer);
+    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glDisableClientState(GLenum array)
 {
-    d_1_1_Deprecated->DisableClientState(array);
+    d_1_1_Deprecated->f.DisableClientState(array);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->ColorPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glArrayElement(GLint i)
 {
-    d_1_1_Deprecated->ArrayElement(i);
+    d_1_1_Deprecated->f.ArrayElement(i);
 }
 
 
 // OpenGL 1.2 deprecated functions
 inline void QOpenGLFunctions_3_2_Compatibility::glResetMinmax(GLenum target)
 {
-    d_1_2_Deprecated->ResetMinmax(target);
+    d_1_2_Deprecated->f.ResetMinmax(target);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glResetHistogram(GLenum target)
 {
-    d_1_2_Deprecated->ResetHistogram(target);
+    d_1_2_Deprecated->f.ResetHistogram(target);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Minmax(target, internalformat, sink);
+    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Histogram(target, width, internalformat, sink);
+    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetMinmax(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetHistogramParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetHistogramParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetHistogram(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
 {
-    d_1_2_Deprecated->SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
+    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
 {
-    d_1_2_Deprecated->GetSeparableFilter(target, format, type, row, column, span);
+    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
 {
-    d_1_2_Deprecated->GetConvolutionFilter(target, format, type, image);
+    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
+    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter1D(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
 {
-    d_1_2_Deprecated->ConvolutionParameteri(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
 {
-    d_1_2_Deprecated->ConvolutionParameterf(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter1D(target, internalformat, width, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorSubTable(target, start, x, y, width);
+    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
 {
-    d_1_2_Deprecated->ColorSubTable(target, start, count, format, type, data);
+    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
 {
-    d_1_2_Deprecated->GetColorTable(target, format, type, table);
+    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorTable(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
 {
-    d_1_2_Deprecated->ColorTable(target, internalformat, width, format, type, table);
+    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
 }
 
 
 // OpenGL 1.3 deprecated functions
 inline void QOpenGLFunctions_3_2_Compatibility::glMultTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixd(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixf(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLoadTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixd(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glLoadTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixf(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord4sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_3_Deprecated->MultiTexCoord4s(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord4iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_3_Deprecated->MultiTexCoord4i(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_3_Deprecated->MultiTexCoord4f(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_3_Deprecated->MultiTexCoord4d(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord3sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
 {
-    d_1_3_Deprecated->MultiTexCoord3s(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord3iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
 {
-    d_1_3_Deprecated->MultiTexCoord3i(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_3_Deprecated->MultiTexCoord3f(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_3_Deprecated->MultiTexCoord3d(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord2sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
 {
-    d_1_3_Deprecated->MultiTexCoord2s(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord2iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
 {
-    d_1_3_Deprecated->MultiTexCoord2i(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
 {
-    d_1_3_Deprecated->MultiTexCoord2f(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
 {
-    d_1_3_Deprecated->MultiTexCoord2d(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord1sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord1s(GLenum target, GLshort s)
 {
-    d_1_3_Deprecated->MultiTexCoord1s(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord1iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord1i(GLenum target, GLint s)
 {
-    d_1_3_Deprecated->MultiTexCoord1i(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord1f(GLenum target, GLfloat s)
 {
-    d_1_3_Deprecated->MultiTexCoord1f(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glMultiTexCoord1d(GLenum target, GLdouble s)
 {
-    d_1_3_Deprecated->MultiTexCoord1d(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glClientActiveTexture(GLenum texture)
 {
-    d_1_3_Deprecated->ClientActiveTexture(texture);
+    d_1_3_Deprecated->f.ClientActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 deprecated functions
 inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos3sv(v);
+    d_1_4_Deprecated->f.WindowPos3sv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_4_Deprecated->WindowPos3s(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos3iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos3iv(v);
+    d_1_4_Deprecated->f.WindowPos3iv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_4_Deprecated->WindowPos3i(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos3fv(v);
+    d_1_4_Deprecated->f.WindowPos3fv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_4_Deprecated->WindowPos3f(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos3dv(v);
+    d_1_4_Deprecated->f.WindowPos3dv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_4_Deprecated->WindowPos3d(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos2sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos2sv(v);
+    d_1_4_Deprecated->f.WindowPos2sv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos2s(GLshort x, GLshort y)
 {
-    d_1_4_Deprecated->WindowPos2s(x, y);
+    d_1_4_Deprecated->f.WindowPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos2iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos2iv(v);
+    d_1_4_Deprecated->f.WindowPos2iv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos2i(GLint x, GLint y)
 {
-    d_1_4_Deprecated->WindowPos2i(x, y);
+    d_1_4_Deprecated->f.WindowPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos2fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos2fv(v);
+    d_1_4_Deprecated->f.WindowPos2fv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos2f(GLfloat x, GLfloat y)
 {
-    d_1_4_Deprecated->WindowPos2f(x, y);
+    d_1_4_Deprecated->f.WindowPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos2dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos2dv(v);
+    d_1_4_Deprecated->f.WindowPos2dv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glWindowPos2d(GLdouble x, GLdouble y)
 {
-    d_1_4_Deprecated->WindowPos2d(x, y);
+    d_1_4_Deprecated->f.WindowPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->SecondaryColorPointer(size, type, stride, pointer);
+    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3usv(const GLushort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3usv(v);
+    d_1_4_Deprecated->f.SecondaryColor3usv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3us(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3uiv(const GLuint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3uiv(v);
+    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ui(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3ubv(const GLubyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3ubv(v);
+    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ub(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3sv(v);
+    d_1_4_Deprecated->f.SecondaryColor3sv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3s(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3iv(const GLint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3iv(v);
+    d_1_4_Deprecated->f.SecondaryColor3iv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3i(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->SecondaryColor3fv(v);
+    d_1_4_Deprecated->f.SecondaryColor3fv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_4_Deprecated->SecondaryColor3f(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->SecondaryColor3dv(v);
+    d_1_4_Deprecated->f.SecondaryColor3dv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_4_Deprecated->SecondaryColor3d(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3bv(const GLbyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3bv(v);
+    d_1_4_Deprecated->f.SecondaryColor3bv(v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3b(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->FogCoordPointer(type, stride, pointer);
+    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFogCoorddv(const GLdouble *coord)
 {
-    d_1_4_Deprecated->FogCoorddv(coord);
+    d_1_4_Deprecated->f.FogCoorddv(coord);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFogCoordd(GLdouble coord)
 {
-    d_1_4_Deprecated->FogCoordd(coord);
+    d_1_4_Deprecated->f.FogCoordd(coord);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFogCoordfv(const GLfloat *coord)
 {
-    d_1_4_Deprecated->FogCoordfv(coord);
+    d_1_4_Deprecated->f.FogCoordfv(coord);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glFogCoordf(GLfloat coord)
 {
-    d_1_4_Deprecated->FogCoordf(coord);
+    d_1_4_Deprecated->f.FogCoordf(coord);
 }
 
 
@@ -4081,182 +4082,182 @@ inline void QOpenGLFunctions_3_2_Compatibility::glFogCoordf(GLfloat coord)
 // OpenGL 2.0 deprecated functions
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4usv(index, v);
+    d_2_0_Core->f.VertexAttrib4usv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4uiv(index, v);
+    d_2_0_Core->f.VertexAttrib4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4ubv(index, v);
+    d_2_0_Core->f.VertexAttrib4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4sv(index, v);
+    d_2_0_Core->f.VertexAttrib4sv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4iv(index, v);
+    d_2_0_Core->f.VertexAttrib4iv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib4fv(index, v);
+    d_2_0_Core->f.VertexAttrib4fv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib4dv(index, v);
+    d_2_0_Core->f.VertexAttrib4dv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4bv(index, v);
+    d_2_0_Core->f.VertexAttrib4bv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4Nusv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4Nuiv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nubv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
 {
-    d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4Nsv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4Niv(index, v);
+    d_2_0_Core->f.VertexAttrib4Niv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nbv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib3sv(index, v);
+    d_2_0_Core->f.VertexAttrib3sv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
 {
-    d_2_0_Core->VertexAttrib3s(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib3fv(index, v);
+    d_2_0_Core->f.VertexAttrib3fv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_2_0_Core->VertexAttrib3f(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib3dv(index, v);
+    d_2_0_Core->f.VertexAttrib3dv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_2_0_Core->VertexAttrib3d(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib2sv(index, v);
+    d_2_0_Core->f.VertexAttrib2sv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
 {
-    d_2_0_Core->VertexAttrib2s(index, x, y);
+    d_2_0_Core->f.VertexAttrib2s(index, x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib2fv(index, v);
+    d_2_0_Core->f.VertexAttrib2fv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
 {
-    d_2_0_Core->VertexAttrib2f(index, x, y);
+    d_2_0_Core->f.VertexAttrib2f(index, x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib2dv(index, v);
+    d_2_0_Core->f.VertexAttrib2dv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_2_0_Core->VertexAttrib2d(index, x, y);
+    d_2_0_Core->f.VertexAttrib2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib1sv(index, v);
+    d_2_0_Core->f.VertexAttrib1sv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
 {
-    d_2_0_Core->VertexAttrib1s(index, x);
+    d_2_0_Core->f.VertexAttrib1s(index, x);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib1fv(index, v);
+    d_2_0_Core->f.VertexAttrib1fv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
 {
-    d_2_0_Core->VertexAttrib1f(index, x);
+    d_2_0_Core->f.VertexAttrib1f(index, x);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib1dv(index, v);
+    d_2_0_Core->f.VertexAttrib1dv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
 {
-    d_2_0_Core->VertexAttrib1d(index, x);
+    d_2_0_Core->f.VertexAttrib1d(index, x);
 }
 
 
@@ -4265,102 +4266,102 @@ inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttrib1d(GLuint index, G
 // OpenGL 3.0 deprecated functions
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
 {
-    d_3_0_Core->VertexAttribI4usv(index, v);
+    d_3_0_Core->f.VertexAttribI4usv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
 {
-    d_3_0_Core->VertexAttribI4ubv(index, v);
+    d_3_0_Core->f.VertexAttribI4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
 {
-    d_3_0_Core->VertexAttribI4sv(index, v);
+    d_3_0_Core->f.VertexAttribI4sv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
 {
-    d_3_0_Core->VertexAttribI4bv(index, v);
+    d_3_0_Core->f.VertexAttribI4bv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI4uiv(index, v);
+    d_3_0_Core->f.VertexAttribI4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI3uiv(index, v);
+    d_3_0_Core->f.VertexAttribI3uiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI2uiv(index, v);
+    d_3_0_Core->f.VertexAttribI2uiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI1uiv(index, v);
+    d_3_0_Core->f.VertexAttribI1uiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI4iv(index, v);
+    d_3_0_Core->f.VertexAttribI4iv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI3iv(index, v);
+    d_3_0_Core->f.VertexAttribI3iv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI2iv(index, v);
+    d_3_0_Core->f.VertexAttribI2iv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI1iv(index, v);
+    d_3_0_Core->f.VertexAttribI1iv(index, v);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
 {
-    d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
 {
-    d_3_0_Core->VertexAttribI3ui(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
 {
-    d_3_0_Core->VertexAttribI2ui(index, x, y);
+    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
 {
-    d_3_0_Core->VertexAttribI1ui(index, x);
+    d_3_0_Core->f.VertexAttribI1ui(index, x);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
 {
-    d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
 {
-    d_3_0_Core->VertexAttribI3i(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
 {
-    d_3_0_Core->VertexAttribI2i(index, x, y);
+    d_3_0_Core->f.VertexAttribI2i(index, x, y);
 }
 
 inline void QOpenGLFunctions_3_2_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
 {
-    d_3_0_Core->VertexAttribI1i(index, x);
+    d_3_0_Core->f.VertexAttribI1i(index, x);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_3_2_core.cpp b/src/gui/opengl/qopenglfunctions_3_2_core.cpp
index 738fd32a375..177dc9e25d2 100644
--- a/src/gui/opengl/qopenglfunctions_3_2_core.cpp
+++ b/src/gui/opengl/qopenglfunctions_3_2_core.cpp
@@ -83,50 +83,39 @@ QOpenGLFunctions_3_2_Core::QOpenGLFunctions_3_2_Core()
 
 QOpenGLFunctions_3_2_Core::~QOpenGLFunctions_3_2_Core()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
-    if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        delete d_3_2_Core;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
+    if (d_3_2_Core)
+        d_3_2_Core->refs.deref();
+    Q_ASSERT(d_3_2_Core->refs.load());
 }
 
 bool QOpenGLFunctions_3_2_Core::initializeOpenGLFunctions()
@@ -145,90 +134,46 @@ bool QOpenGLFunctions_3_2_Core::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
-        }
         d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_3_2_core.h b/src/gui/opengl/qopenglfunctions_3_2_core.h
index e899d75ab5e..36f959c04ba 100644
--- a/src/gui/opengl/qopenglfunctions_3_2_core.h
+++ b/src/gui/opengl/qopenglfunctions_3_2_core.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -373,242 +374,242 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_3_2_Core::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Core::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_3_2_Core::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_3_2_Core::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_3_2_Core::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_3_2_Core::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
@@ -627,57 +628,57 @@ inline void QOpenGLFunctions_3_2_Core::glIndexub(GLubyte c)
 
 inline GLboolean QOpenGLFunctions_3_2_Core::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetPointerv(GLenum pname, GLvoid* *params)
@@ -689,1025 +690,1025 @@ inline void QOpenGLFunctions_3_2_Core::glGetPointerv(GLenum pname, GLvoid* *para
 
 inline void QOpenGLFunctions_3_2_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_3_2_Core::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_3_2_Core::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_3_2_Core::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_3_2_Core::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Core::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_3_2_Core::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Core::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Core::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_3_2_Core::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Core::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Core::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_3_2_Core::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_3_2_Core::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, obj);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_3_2_Core::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_3_2_Core::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_3_2_Core::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_3_2_Core::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_3_2_Core::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline GLvoid* QOpenGLFunctions_3_2_Core::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_3_2_Core::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Core::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Core::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_3_2_Core::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_3_2_Core::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_3_2_Core::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Core::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_3_2_Core::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_3_2_Core::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
 // OpenGL 3.2 core functions
 inline void QOpenGLFunctions_3_2_Core::glSampleMaski(GLuint index, GLbitfield mask)
 {
-    d_3_2_Core->SampleMaski(index, mask);
+    d_3_2_Core->f.SampleMaski(index, mask);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
 {
-    d_3_2_Core->GetMultisamplefv(pname, index, val);
+    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
-    d_3_2_Core->GetSynciv(sync, pname, bufSize, length, values);
+    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetInteger64v(GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetInteger64v(pname, params);
+    d_3_2_Core->f.GetInteger64v(pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    d_3_2_Core->WaitSync(sync, flags, timeout);
+    d_3_2_Core->f.WaitSync(sync, flags, timeout);
 }
 
 inline GLenum QOpenGLFunctions_3_2_Core::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    return d_3_2_Core->ClientWaitSync(sync, flags, timeout);
+    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDeleteSync(GLsync sync)
 {
-    d_3_2_Core->DeleteSync(sync);
+    d_3_2_Core->f.DeleteSync(sync);
 }
 
 inline GLboolean QOpenGLFunctions_3_2_Core::glIsSync(GLsync sync)
 {
-    return d_3_2_Core->IsSync(sync);
+    return d_3_2_Core->f.IsSync(sync);
 }
 
 inline GLsync QOpenGLFunctions_3_2_Core::glFenceSync(GLenum condition, GLbitfield flags)
 {
-    return d_3_2_Core->FenceSync(condition, flags);
+    return d_3_2_Core->f.FenceSync(condition, flags);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glProvokingVertex(GLenum mode)
 {
-    d_3_2_Core->ProvokingVertex(mode);
+    d_3_2_Core->f.ProvokingVertex(mode);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
 {
-    d_3_2_Core->MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
-    d_3_2_Core->FramebufferTexture(target, attachment, texture, level);
+    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetBufferParameteri64v(target, pname, params);
+    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_2_Core::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64i_v(target, index, data);
+    d_3_2_Core->f.GetInteger64i_v(target, index, data);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_3_3_compatibility.cpp b/src/gui/opengl/qopenglfunctions_3_3_compatibility.cpp
index 89bcf84a917..110a49ea53b 100644
--- a/src/gui/opengl/qopenglfunctions_3_3_compatibility.cpp
+++ b/src/gui/opengl/qopenglfunctions_3_3_compatibility.cpp
@@ -91,78 +91,60 @@ QOpenGLFunctions_3_3_Compatibility::QOpenGLFunctions_3_3_Compatibility()
 
 QOpenGLFunctions_3_3_Compatibility::~QOpenGLFunctions_3_3_Compatibility()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
-    if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        delete d_3_2_Core;
-    }
-    if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        delete d_3_3_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
-    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        delete d_1_1_Deprecated;
-    }
-    if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        delete d_1_2_Deprecated;
-    }
-    if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        delete d_1_3_Deprecated;
-    }
-    if (d_1_4_Deprecated && !d_1_4_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        delete d_1_4_Deprecated;
-    }
-    if (d_3_3_Deprecated && !d_3_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Deprecated->context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        delete d_3_3_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
+    if (d_3_2_Core)
+        d_3_2_Core->refs.deref();
+    Q_ASSERT(d_3_2_Core->refs.load());
+    if (d_3_3_Core)
+        d_3_3_Core->refs.deref();
+    Q_ASSERT(d_3_3_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
+    if (d_1_1_Deprecated)
+        d_1_1_Deprecated->refs.deref();
+    Q_ASSERT(d_1_1_Deprecated->refs.load());
+    if (d_1_2_Deprecated)
+        d_1_2_Deprecated->refs.deref();
+    Q_ASSERT(d_1_2_Deprecated->refs.load());
+    if (d_1_3_Deprecated)
+        d_1_3_Deprecated->refs.deref();
+    Q_ASSERT(d_1_3_Deprecated->refs.load());
+    if (d_1_4_Deprecated)
+        d_1_4_Deprecated->refs.deref();
+    Q_ASSERT(d_1_4_Deprecated->refs.load());
+    if (d_3_3_Deprecated)
+        d_3_3_Deprecated->refs.deref();
+    Q_ASSERT(d_3_3_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_3_3_Compatibility::initializeOpenGLFunctions()
@@ -181,146 +163,74 @@ bool QOpenGLFunctions_3_3_Compatibility::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
-        }
         d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
-        }
         d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_3_3_compatibility.h b/src/gui/opengl/qopenglfunctions_3_3_compatibility.h
index 8cad5f8af3e..126cc168584 100644
--- a/src/gui/opengl/qopenglfunctions_3_3_compatibility.h
+++ b/src/gui/opengl/qopenglfunctions_3_3_compatibility.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -900,3534 +901,3534 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_3_3_Compatibility::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_3_3_Compatibility::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_3_3_Compatibility::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline void QOpenGLFunctions_3_3_Compatibility::glIndexubv(const GLubyte *c)
 {
-    d_1_1_Deprecated->Indexubv(c);
+    d_1_1_Deprecated->f.Indexubv(c);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glIndexub(GLubyte c)
 {
-    d_1_1_Deprecated->Indexub(c);
+    d_1_1_Deprecated->f.Indexub(c);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
 {
-    d_1_1_Deprecated->GetPointerv(pname, params);
+    d_1_1_Deprecated->f.GetPointerv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_3_3_Compatibility::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_3_3_Compatibility::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_3_3_Compatibility::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_3_3_Compatibility::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Compatibility::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_3_3_Compatibility::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_3_3_Compatibility::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_3_3_Compatibility::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, obj);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_3_3_Compatibility::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_3_3_Compatibility::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline GLvoid* QOpenGLFunctions_3_3_Compatibility::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_3_3_Compatibility::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_3_3_Compatibility::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_3_3_Compatibility::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_3_3_Compatibility::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_3_3_Compatibility::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
 // OpenGL 3.2 core functions
 inline void QOpenGLFunctions_3_3_Compatibility::glSampleMaski(GLuint index, GLbitfield mask)
 {
-    d_3_2_Core->SampleMaski(index, mask);
+    d_3_2_Core->f.SampleMaski(index, mask);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
 {
-    d_3_2_Core->GetMultisamplefv(pname, index, val);
+    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
-    d_3_2_Core->GetSynciv(sync, pname, bufSize, length, values);
+    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetInteger64v(GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetInteger64v(pname, params);
+    d_3_2_Core->f.GetInteger64v(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    d_3_2_Core->WaitSync(sync, flags, timeout);
+    d_3_2_Core->f.WaitSync(sync, flags, timeout);
 }
 
 inline GLenum QOpenGLFunctions_3_3_Compatibility::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    return d_3_2_Core->ClientWaitSync(sync, flags, timeout);
+    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDeleteSync(GLsync sync)
 {
-    d_3_2_Core->DeleteSync(sync);
+    d_3_2_Core->f.DeleteSync(sync);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsSync(GLsync sync)
 {
-    return d_3_2_Core->IsSync(sync);
+    return d_3_2_Core->f.IsSync(sync);
 }
 
 inline GLsync QOpenGLFunctions_3_3_Compatibility::glFenceSync(GLenum condition, GLbitfield flags)
 {
-    return d_3_2_Core->FenceSync(condition, flags);
+    return d_3_2_Core->f.FenceSync(condition, flags);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glProvokingVertex(GLenum mode)
 {
-    d_3_2_Core->ProvokingVertex(mode);
+    d_3_2_Core->f.ProvokingVertex(mode);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
 {
-    d_3_2_Core->MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
-    d_3_2_Core->FramebufferTexture(target, attachment, texture, level);
+    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetBufferParameteri64v(target, pname, params);
+    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64i_v(target, index, data);
+    d_3_2_Core->f.GetInteger64i_v(target, index, data);
 }
 
 
 // OpenGL 3.3 core functions
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP4uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP4ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP3uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP3ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP2uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP2ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP1uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP1ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->SecondaryColorP3uiv(type, color);
+    d_3_3_Deprecated->f.SecondaryColorP3uiv(type, color);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->SecondaryColorP3ui(type, color);
+    d_3_3_Deprecated->f.SecondaryColorP3ui(type, color);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->ColorP4uiv(type, color);
+    d_3_3_Deprecated->f.ColorP4uiv(type, color);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColorP4ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->ColorP4ui(type, color);
+    d_3_3_Deprecated->f.ColorP4ui(type, color);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->ColorP3uiv(type, color);
+    d_3_3_Deprecated->f.ColorP3uiv(type, color);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColorP3ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->ColorP3ui(type, color);
+    d_3_3_Deprecated->f.ColorP3ui(type, color);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->NormalP3uiv(type, coords);
+    d_3_3_Deprecated->f.NormalP3uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->NormalP3ui(type, coords);
+    d_3_3_Deprecated->f.NormalP3ui(type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP4uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP4uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP4ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP4ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP3uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP3uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP3ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP3ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP2uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP2uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP2ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP2ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP1uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP1uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP1ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP1ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP4uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP4uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP4ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP4ui(type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP3uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP3uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP3ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP3ui(type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP2uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP2uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP2ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP2ui(type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP1uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP1uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP1ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP1ui(type, coords);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP4uiv(type, value);
+    d_3_3_Deprecated->f.VertexP4uiv(type, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexP4ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP4ui(type, value);
+    d_3_3_Deprecated->f.VertexP4ui(type, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP3uiv(type, value);
+    d_3_3_Deprecated->f.VertexP3uiv(type, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexP3ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP3ui(type, value);
+    d_3_3_Deprecated->f.VertexP3ui(type, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP2uiv(type, value);
+    d_3_3_Deprecated->f.VertexP2uiv(type, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexP2ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP2ui(type, value);
+    d_3_3_Deprecated->f.VertexP2ui(type, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
 {
-    d_3_3_Core->GetQueryObjectui64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
 {
-    d_3_3_Core->GetQueryObjecti64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glQueryCounter(GLuint id, GLenum target)
 {
-    d_3_3_Core->QueryCounter(id, target);
+    d_3_3_Core->f.QueryCounter(id, target);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
 {
-    d_3_3_Core->GetSamplerParameterIuiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
 {
-    d_3_3_Core->GetSamplerParameterfv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameterIiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameteriv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
 {
-    d_3_3_Core->SamplerParameterIuiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameterIiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
 {
-    d_3_3_Core->SamplerParameterfv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
 {
-    d_3_3_Core->SamplerParameterf(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameteriv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
-    d_3_3_Core->SamplerParameteri(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBindSampler(GLuint unit, GLuint sampler)
 {
-    d_3_3_Core->BindSampler(unit, sampler);
+    d_3_3_Core->f.BindSampler(unit, sampler);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsSampler(GLuint sampler)
 {
-    return d_3_3_Core->IsSampler(sampler);
+    return d_3_3_Core->f.IsSampler(sampler);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDeleteSamplers(GLsizei count, const GLuint *samplers)
 {
-    d_3_3_Core->DeleteSamplers(count, samplers);
+    d_3_3_Core->f.DeleteSamplers(count, samplers);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGenSamplers(GLsizei count, GLuint *samplers)
 {
-    d_3_3_Core->GenSamplers(count, samplers);
+    d_3_3_Core->f.GenSamplers(count, samplers);
 }
 
 inline GLint QOpenGLFunctions_3_3_Compatibility::glGetFragDataIndex(GLuint program, const GLchar *name)
 {
-    return d_3_3_Core->GetFragDataIndex(program, name);
+    return d_3_3_Core->f.GetFragDataIndex(program, name);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
 {
-    d_3_3_Core->BindFragDataLocationIndexed(program, colorNumber, index, name);
+    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribDivisor(GLuint index, GLuint divisor)
 {
-    d_3_3_Core->VertexAttribDivisor(index, divisor);
+    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_3_3_Compatibility::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Compatibility::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_3_3_Compatibility::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_3_3_Compatibility::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
 // OpenGL 1.1 deprecated functions
 inline void QOpenGLFunctions_3_3_Compatibility::glPushClientAttrib(GLbitfield mask)
 {
-    d_1_1_Deprecated->PushClientAttrib(mask);
+    d_1_1_Deprecated->f.PushClientAttrib(mask);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPopClientAttrib()
 {
-    d_1_1_Deprecated->PopClientAttrib();
+    d_1_1_Deprecated->f.PopClientAttrib();
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 {
-    d_1_1_Deprecated->PrioritizeTextures(n, textures, priorities);
+    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Compatibility::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-    return d_1_1_Deprecated->AreTexturesResident(n, textures, residences);
+    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->VertexPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->TexCoordPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->NormalPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->InterleavedArrays(format, stride, pointer);
+    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->IndexPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEnableClientState(GLenum array)
 {
-    d_1_1_Deprecated->EnableClientState(array);
+    d_1_1_Deprecated->f.EnableClientState(array);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->EdgeFlagPointer(stride, pointer);
+    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glDisableClientState(GLenum array)
 {
-    d_1_1_Deprecated->DisableClientState(array);
+    d_1_1_Deprecated->f.DisableClientState(array);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->ColorPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glArrayElement(GLint i)
 {
-    d_1_1_Deprecated->ArrayElement(i);
+    d_1_1_Deprecated->f.ArrayElement(i);
 }
 
 
 // OpenGL 1.2 deprecated functions
 inline void QOpenGLFunctions_3_3_Compatibility::glResetMinmax(GLenum target)
 {
-    d_1_2_Deprecated->ResetMinmax(target);
+    d_1_2_Deprecated->f.ResetMinmax(target);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glResetHistogram(GLenum target)
 {
-    d_1_2_Deprecated->ResetHistogram(target);
+    d_1_2_Deprecated->f.ResetHistogram(target);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Minmax(target, internalformat, sink);
+    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Histogram(target, width, internalformat, sink);
+    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetMinmax(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetHistogramParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetHistogramParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetHistogram(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
 {
-    d_1_2_Deprecated->SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
+    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
 {
-    d_1_2_Deprecated->GetSeparableFilter(target, format, type, row, column, span);
+    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
 {
-    d_1_2_Deprecated->GetConvolutionFilter(target, format, type, image);
+    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
+    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter1D(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
 {
-    d_1_2_Deprecated->ConvolutionParameteri(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
 {
-    d_1_2_Deprecated->ConvolutionParameterf(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter1D(target, internalformat, width, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorSubTable(target, start, x, y, width);
+    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
 {
-    d_1_2_Deprecated->ColorSubTable(target, start, count, format, type, data);
+    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
 {
-    d_1_2_Deprecated->GetColorTable(target, format, type, table);
+    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorTable(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
 {
-    d_1_2_Deprecated->ColorTable(target, internalformat, width, format, type, table);
+    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
 }
 
 
 // OpenGL 1.3 deprecated functions
 inline void QOpenGLFunctions_3_3_Compatibility::glMultTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixd(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixf(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLoadTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixd(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glLoadTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixf(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_3_Deprecated->MultiTexCoord4s(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_3_Deprecated->MultiTexCoord4i(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_3_Deprecated->MultiTexCoord4f(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_3_Deprecated->MultiTexCoord4d(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
 {
-    d_1_3_Deprecated->MultiTexCoord3s(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
 {
-    d_1_3_Deprecated->MultiTexCoord3i(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_3_Deprecated->MultiTexCoord3f(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_3_Deprecated->MultiTexCoord3d(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
 {
-    d_1_3_Deprecated->MultiTexCoord2s(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
 {
-    d_1_3_Deprecated->MultiTexCoord2i(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
 {
-    d_1_3_Deprecated->MultiTexCoord2f(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
 {
-    d_1_3_Deprecated->MultiTexCoord2d(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1s(GLenum target, GLshort s)
 {
-    d_1_3_Deprecated->MultiTexCoord1s(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1i(GLenum target, GLint s)
 {
-    d_1_3_Deprecated->MultiTexCoord1i(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1f(GLenum target, GLfloat s)
 {
-    d_1_3_Deprecated->MultiTexCoord1f(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1d(GLenum target, GLdouble s)
 {
-    d_1_3_Deprecated->MultiTexCoord1d(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glClientActiveTexture(GLenum texture)
 {
-    d_1_3_Deprecated->ClientActiveTexture(texture);
+    d_1_3_Deprecated->f.ClientActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 deprecated functions
 inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos3sv(v);
+    d_1_4_Deprecated->f.WindowPos3sv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_4_Deprecated->WindowPos3s(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos3iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos3iv(v);
+    d_1_4_Deprecated->f.WindowPos3iv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_4_Deprecated->WindowPos3i(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos3fv(v);
+    d_1_4_Deprecated->f.WindowPos3fv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_4_Deprecated->WindowPos3f(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos3dv(v);
+    d_1_4_Deprecated->f.WindowPos3dv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_4_Deprecated->WindowPos3d(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos2sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos2sv(v);
+    d_1_4_Deprecated->f.WindowPos2sv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos2s(GLshort x, GLshort y)
 {
-    d_1_4_Deprecated->WindowPos2s(x, y);
+    d_1_4_Deprecated->f.WindowPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos2iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos2iv(v);
+    d_1_4_Deprecated->f.WindowPos2iv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos2i(GLint x, GLint y)
 {
-    d_1_4_Deprecated->WindowPos2i(x, y);
+    d_1_4_Deprecated->f.WindowPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos2fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos2fv(v);
+    d_1_4_Deprecated->f.WindowPos2fv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos2f(GLfloat x, GLfloat y)
 {
-    d_1_4_Deprecated->WindowPos2f(x, y);
+    d_1_4_Deprecated->f.WindowPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos2dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos2dv(v);
+    d_1_4_Deprecated->f.WindowPos2dv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glWindowPos2d(GLdouble x, GLdouble y)
 {
-    d_1_4_Deprecated->WindowPos2d(x, y);
+    d_1_4_Deprecated->f.WindowPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->SecondaryColorPointer(size, type, stride, pointer);
+    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3usv(const GLushort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3usv(v);
+    d_1_4_Deprecated->f.SecondaryColor3usv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3us(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3uiv(const GLuint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3uiv(v);
+    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ui(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3ubv(const GLubyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3ubv(v);
+    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ub(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3sv(v);
+    d_1_4_Deprecated->f.SecondaryColor3sv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3s(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3iv(const GLint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3iv(v);
+    d_1_4_Deprecated->f.SecondaryColor3iv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3i(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->SecondaryColor3fv(v);
+    d_1_4_Deprecated->f.SecondaryColor3fv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_4_Deprecated->SecondaryColor3f(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->SecondaryColor3dv(v);
+    d_1_4_Deprecated->f.SecondaryColor3dv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_4_Deprecated->SecondaryColor3d(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3bv(const GLbyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3bv(v);
+    d_1_4_Deprecated->f.SecondaryColor3bv(v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3b(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->FogCoordPointer(type, stride, pointer);
+    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFogCoorddv(const GLdouble *coord)
 {
-    d_1_4_Deprecated->FogCoorddv(coord);
+    d_1_4_Deprecated->f.FogCoorddv(coord);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFogCoordd(GLdouble coord)
 {
-    d_1_4_Deprecated->FogCoordd(coord);
+    d_1_4_Deprecated->f.FogCoordd(coord);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFogCoordfv(const GLfloat *coord)
 {
-    d_1_4_Deprecated->FogCoordfv(coord);
+    d_1_4_Deprecated->f.FogCoordfv(coord);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glFogCoordf(GLfloat coord)
 {
-    d_1_4_Deprecated->FogCoordf(coord);
+    d_1_4_Deprecated->f.FogCoordf(coord);
 }
 
 
@@ -4436,182 +4437,182 @@ inline void QOpenGLFunctions_3_3_Compatibility::glFogCoordf(GLfloat coord)
 // OpenGL 2.0 deprecated functions
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4usv(index, v);
+    d_2_0_Core->f.VertexAttrib4usv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4uiv(index, v);
+    d_2_0_Core->f.VertexAttrib4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4ubv(index, v);
+    d_2_0_Core->f.VertexAttrib4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4sv(index, v);
+    d_2_0_Core->f.VertexAttrib4sv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4iv(index, v);
+    d_2_0_Core->f.VertexAttrib4iv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib4fv(index, v);
+    d_2_0_Core->f.VertexAttrib4fv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib4dv(index, v);
+    d_2_0_Core->f.VertexAttrib4dv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4bv(index, v);
+    d_2_0_Core->f.VertexAttrib4bv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4Nusv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4Nuiv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nubv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
 {
-    d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4Nsv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4Niv(index, v);
+    d_2_0_Core->f.VertexAttrib4Niv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nbv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib3sv(index, v);
+    d_2_0_Core->f.VertexAttrib3sv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
 {
-    d_2_0_Core->VertexAttrib3s(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib3fv(index, v);
+    d_2_0_Core->f.VertexAttrib3fv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_2_0_Core->VertexAttrib3f(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib3dv(index, v);
+    d_2_0_Core->f.VertexAttrib3dv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_2_0_Core->VertexAttrib3d(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib2sv(index, v);
+    d_2_0_Core->f.VertexAttrib2sv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
 {
-    d_2_0_Core->VertexAttrib2s(index, x, y);
+    d_2_0_Core->f.VertexAttrib2s(index, x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib2fv(index, v);
+    d_2_0_Core->f.VertexAttrib2fv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
 {
-    d_2_0_Core->VertexAttrib2f(index, x, y);
+    d_2_0_Core->f.VertexAttrib2f(index, x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib2dv(index, v);
+    d_2_0_Core->f.VertexAttrib2dv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_2_0_Core->VertexAttrib2d(index, x, y);
+    d_2_0_Core->f.VertexAttrib2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib1sv(index, v);
+    d_2_0_Core->f.VertexAttrib1sv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
 {
-    d_2_0_Core->VertexAttrib1s(index, x);
+    d_2_0_Core->f.VertexAttrib1s(index, x);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib1fv(index, v);
+    d_2_0_Core->f.VertexAttrib1fv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
 {
-    d_2_0_Core->VertexAttrib1f(index, x);
+    d_2_0_Core->f.VertexAttrib1f(index, x);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib1dv(index, v);
+    d_2_0_Core->f.VertexAttrib1dv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
 {
-    d_2_0_Core->VertexAttrib1d(index, x);
+    d_2_0_Core->f.VertexAttrib1d(index, x);
 }
 
 
@@ -4620,102 +4621,102 @@ inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1d(GLuint index, G
 // OpenGL 3.0 deprecated functions
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
 {
-    d_3_0_Core->VertexAttribI4usv(index, v);
+    d_3_0_Core->f.VertexAttribI4usv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
 {
-    d_3_0_Core->VertexAttribI4ubv(index, v);
+    d_3_0_Core->f.VertexAttribI4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
 {
-    d_3_0_Core->VertexAttribI4sv(index, v);
+    d_3_0_Core->f.VertexAttribI4sv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
 {
-    d_3_0_Core->VertexAttribI4bv(index, v);
+    d_3_0_Core->f.VertexAttribI4bv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI4uiv(index, v);
+    d_3_0_Core->f.VertexAttribI4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI3uiv(index, v);
+    d_3_0_Core->f.VertexAttribI3uiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI2uiv(index, v);
+    d_3_0_Core->f.VertexAttribI2uiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI1uiv(index, v);
+    d_3_0_Core->f.VertexAttribI1uiv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI4iv(index, v);
+    d_3_0_Core->f.VertexAttribI4iv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI3iv(index, v);
+    d_3_0_Core->f.VertexAttribI3iv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI2iv(index, v);
+    d_3_0_Core->f.VertexAttribI2iv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI1iv(index, v);
+    d_3_0_Core->f.VertexAttribI1iv(index, v);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
 {
-    d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
 {
-    d_3_0_Core->VertexAttribI3ui(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
 {
-    d_3_0_Core->VertexAttribI2ui(index, x, y);
+    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
 {
-    d_3_0_Core->VertexAttribI1ui(index, x);
+    d_3_0_Core->f.VertexAttribI1ui(index, x);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
 {
-    d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
 {
-    d_3_0_Core->VertexAttribI3i(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
 {
-    d_3_0_Core->VertexAttribI2i(index, x, y);
+    d_3_0_Core->f.VertexAttribI2i(index, x, y);
 }
 
 inline void QOpenGLFunctions_3_3_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
 {
-    d_3_0_Core->VertexAttribI1i(index, x);
+    d_3_0_Core->f.VertexAttribI1i(index, x);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_3_3_core.cpp b/src/gui/opengl/qopenglfunctions_3_3_core.cpp
index fc9ad6951ca..2e706724d91 100644
--- a/src/gui/opengl/qopenglfunctions_3_3_core.cpp
+++ b/src/gui/opengl/qopenglfunctions_3_3_core.cpp
@@ -84,54 +84,42 @@ QOpenGLFunctions_3_3_Core::QOpenGLFunctions_3_3_Core()
 
 QOpenGLFunctions_3_3_Core::~QOpenGLFunctions_3_3_Core()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
-    if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        delete d_3_2_Core;
-    }
-    if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        delete d_3_3_Core;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
+    if (d_3_2_Core)
+        d_3_2_Core->refs.deref();
+    Q_ASSERT(d_3_2_Core->refs.load());
+    if (d_3_3_Core)
+        d_3_3_Core->refs.deref();
+    Q_ASSERT(d_3_3_Core->refs.load());
 }
 
 bool QOpenGLFunctions_3_3_Core::initializeOpenGLFunctions()
@@ -150,98 +138,50 @@ bool QOpenGLFunctions_3_3_Core::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
-        }
         d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
-        }
         d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_3_3_core.h b/src/gui/opengl/qopenglfunctions_3_3_core.h
index 7bcbefada7d..15a62802abd 100644
--- a/src/gui/opengl/qopenglfunctions_3_3_core.h
+++ b/src/gui/opengl/qopenglfunctions_3_3_core.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -434,242 +435,242 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_3_3_Core::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Core::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_3_3_Core::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_3_3_Core::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_3_3_Core::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_3_3_Core::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
@@ -688,57 +689,57 @@ inline void QOpenGLFunctions_3_3_Core::glIndexub(GLubyte c)
 
 inline GLboolean QOpenGLFunctions_3_3_Core::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetPointerv(GLenum pname, GLvoid* *params)
@@ -750,1067 +751,1067 @@ inline void QOpenGLFunctions_3_3_Core::glGetPointerv(GLenum pname, GLvoid* *para
 
 inline void QOpenGLFunctions_3_3_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_3_3_Core::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_3_3_Core::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_3_3_Core::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_3_3_Core::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Core::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_3_3_Core::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Core::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Core::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_3_3_Core::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Core::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Core::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_3_3_Core::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_3_3_Core::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, obj);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_3_3_Core::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_3_3_Core::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_3_3_Core::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_3_3_Core::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_3_3_Core::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline GLvoid* QOpenGLFunctions_3_3_Core::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_3_3_Core::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Core::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Core::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_3_3_Core::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_3_3_Core::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Core::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_3_3_Core::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_3_3_Core::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
 // OpenGL 3.2 core functions
 inline void QOpenGLFunctions_3_3_Core::glSampleMaski(GLuint index, GLbitfield mask)
 {
-    d_3_2_Core->SampleMaski(index, mask);
+    d_3_2_Core->f.SampleMaski(index, mask);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
 {
-    d_3_2_Core->GetMultisamplefv(pname, index, val);
+    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
-    d_3_2_Core->GetSynciv(sync, pname, bufSize, length, values);
+    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetInteger64v(GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetInteger64v(pname, params);
+    d_3_2_Core->f.GetInteger64v(pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    d_3_2_Core->WaitSync(sync, flags, timeout);
+    d_3_2_Core->f.WaitSync(sync, flags, timeout);
 }
 
 inline GLenum QOpenGLFunctions_3_3_Core::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    return d_3_2_Core->ClientWaitSync(sync, flags, timeout);
+    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDeleteSync(GLsync sync)
 {
-    d_3_2_Core->DeleteSync(sync);
+    d_3_2_Core->f.DeleteSync(sync);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Core::glIsSync(GLsync sync)
 {
-    return d_3_2_Core->IsSync(sync);
+    return d_3_2_Core->f.IsSync(sync);
 }
 
 inline GLsync QOpenGLFunctions_3_3_Core::glFenceSync(GLenum condition, GLbitfield flags)
 {
-    return d_3_2_Core->FenceSync(condition, flags);
+    return d_3_2_Core->f.FenceSync(condition, flags);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glProvokingVertex(GLenum mode)
 {
-    d_3_2_Core->ProvokingVertex(mode);
+    d_3_2_Core->f.ProvokingVertex(mode);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
 {
-    d_3_2_Core->MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
-    d_3_2_Core->FramebufferTexture(target, attachment, texture, level);
+    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetBufferParameteri64v(target, pname, params);
+    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64i_v(target, index, data);
+    d_3_2_Core->f.GetInteger64i_v(target, index, data);
 }
 
 
 // OpenGL 3.3 core functions
 inline void QOpenGLFunctions_3_3_Core::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP4uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP4ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP3uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP3ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP2uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP2ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP1uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP1ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
@@ -2033,102 +2034,102 @@ inline void QOpenGLFunctions_3_3_Core::glVertexP2ui(GLenum type, GLuint value)
 
 inline void QOpenGLFunctions_3_3_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
 {
-    d_3_3_Core->GetQueryObjectui64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
 {
-    d_3_3_Core->GetQueryObjecti64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glQueryCounter(GLuint id, GLenum target)
 {
-    d_3_3_Core->QueryCounter(id, target);
+    d_3_3_Core->f.QueryCounter(id, target);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
 {
-    d_3_3_Core->GetSamplerParameterIuiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
 {
-    d_3_3_Core->GetSamplerParameterfv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameterIiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameteriv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
 {
-    d_3_3_Core->SamplerParameterIuiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameterIiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
 {
-    d_3_3_Core->SamplerParameterfv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
 {
-    d_3_3_Core->SamplerParameterf(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameteriv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
-    d_3_3_Core->SamplerParameteri(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBindSampler(GLuint unit, GLuint sampler)
 {
-    d_3_3_Core->BindSampler(unit, sampler);
+    d_3_3_Core->f.BindSampler(unit, sampler);
 }
 
 inline GLboolean QOpenGLFunctions_3_3_Core::glIsSampler(GLuint sampler)
 {
-    return d_3_3_Core->IsSampler(sampler);
+    return d_3_3_Core->f.IsSampler(sampler);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glDeleteSamplers(GLsizei count, const GLuint *samplers)
 {
-    d_3_3_Core->DeleteSamplers(count, samplers);
+    d_3_3_Core->f.DeleteSamplers(count, samplers);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glGenSamplers(GLsizei count, GLuint *samplers)
 {
-    d_3_3_Core->GenSamplers(count, samplers);
+    d_3_3_Core->f.GenSamplers(count, samplers);
 }
 
 inline GLint QOpenGLFunctions_3_3_Core::glGetFragDataIndex(GLuint program, const GLchar *name)
 {
-    return d_3_3_Core->GetFragDataIndex(program, name);
+    return d_3_3_Core->f.GetFragDataIndex(program, name);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
 {
-    d_3_3_Core->BindFragDataLocationIndexed(program, colorNumber, index, name);
+    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
 }
 
 inline void QOpenGLFunctions_3_3_Core::glVertexAttribDivisor(GLuint index, GLuint divisor)
 {
-    d_3_3_Core->VertexAttribDivisor(index, divisor);
+    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_4_0_compatibility.cpp b/src/gui/opengl/qopenglfunctions_4_0_compatibility.cpp
index cc2b145ff47..14fb168c94a 100644
--- a/src/gui/opengl/qopenglfunctions_4_0_compatibility.cpp
+++ b/src/gui/opengl/qopenglfunctions_4_0_compatibility.cpp
@@ -92,82 +92,63 @@ QOpenGLFunctions_4_0_Compatibility::QOpenGLFunctions_4_0_Compatibility()
 
 QOpenGLFunctions_4_0_Compatibility::~QOpenGLFunctions_4_0_Compatibility()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
-    if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        delete d_3_2_Core;
-    }
-    if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        delete d_3_3_Core;
-    }
-    if (d_4_0_Core && !d_4_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_0_Core->context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        delete d_4_0_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
-    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        delete d_1_1_Deprecated;
-    }
-    if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        delete d_1_2_Deprecated;
-    }
-    if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        delete d_1_3_Deprecated;
-    }
-    if (d_1_4_Deprecated && !d_1_4_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        delete d_1_4_Deprecated;
-    }
-    if (d_3_3_Deprecated && !d_3_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Deprecated->context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        delete d_3_3_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
+    if (d_3_2_Core)
+        d_3_2_Core->refs.deref();
+    Q_ASSERT(d_3_2_Core->refs.load());
+    if (d_3_3_Core)
+        d_3_3_Core->refs.deref();
+    Q_ASSERT(d_3_3_Core->refs.load());
+    if (d_4_0_Core)
+        d_4_0_Core->refs.deref();
+    Q_ASSERT(d_4_0_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
+    if (d_1_1_Deprecated)
+        d_1_1_Deprecated->refs.deref();
+    Q_ASSERT(d_1_1_Deprecated->refs.load());
+    if (d_1_2_Deprecated)
+        d_1_2_Deprecated->refs.deref();
+    Q_ASSERT(d_1_2_Deprecated->refs.load());
+    if (d_1_3_Deprecated)
+        d_1_3_Deprecated->refs.deref();
+    Q_ASSERT(d_1_3_Deprecated->refs.load());
+    if (d_1_4_Deprecated)
+        d_1_4_Deprecated->refs.deref();
+    Q_ASSERT(d_1_4_Deprecated->refs.load());
+    if (d_3_3_Deprecated)
+        d_3_3_Deprecated->refs.deref();
+    Q_ASSERT(d_3_3_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_4_0_Compatibility::initializeOpenGLFunctions()
@@ -186,154 +167,78 @@ bool QOpenGLFunctions_4_0_Compatibility::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
-        }
         d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
-        }
         d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus(), d);
-        }
         d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_4_0_compatibility.h b/src/gui/opengl/qopenglfunctions_4_0_compatibility.h
index eb8c556177e..9ca6eb8a36e 100644
--- a/src/gui/opengl/qopenglfunctions_4_0_compatibility.h
+++ b/src/gui/opengl/qopenglfunctions_4_0_compatibility.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -951,3766 +952,3766 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_4_0_Compatibility::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_0_Compatibility::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_4_0_Compatibility::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline void QOpenGLFunctions_4_0_Compatibility::glIndexubv(const GLubyte *c)
 {
-    d_1_1_Deprecated->Indexubv(c);
+    d_1_1_Deprecated->f.Indexubv(c);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glIndexub(GLubyte c)
 {
-    d_1_1_Deprecated->Indexub(c);
+    d_1_1_Deprecated->f.Indexub(c);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
 {
-    d_1_1_Deprecated->GetPointerv(pname, params);
+    d_1_1_Deprecated->f.GetPointerv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_4_0_Compatibility::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_4_0_Compatibility::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_4_0_Compatibility::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_4_0_Compatibility::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Compatibility::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_4_0_Compatibility::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_4_0_Compatibility::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_4_0_Compatibility::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, obj);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_4_0_Compatibility::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_4_0_Compatibility::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline GLvoid* QOpenGLFunctions_4_0_Compatibility::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_4_0_Compatibility::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_0_Compatibility::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_4_0_Compatibility::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_4_0_Compatibility::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_4_0_Compatibility::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
 // OpenGL 3.2 core functions
 inline void QOpenGLFunctions_4_0_Compatibility::glSampleMaski(GLuint index, GLbitfield mask)
 {
-    d_3_2_Core->SampleMaski(index, mask);
+    d_3_2_Core->f.SampleMaski(index, mask);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
 {
-    d_3_2_Core->GetMultisamplefv(pname, index, val);
+    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
-    d_3_2_Core->GetSynciv(sync, pname, bufSize, length, values);
+    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetInteger64v(GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetInteger64v(pname, params);
+    d_3_2_Core->f.GetInteger64v(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    d_3_2_Core->WaitSync(sync, flags, timeout);
+    d_3_2_Core->f.WaitSync(sync, flags, timeout);
 }
 
 inline GLenum QOpenGLFunctions_4_0_Compatibility::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    return d_3_2_Core->ClientWaitSync(sync, flags, timeout);
+    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDeleteSync(GLsync sync)
 {
-    d_3_2_Core->DeleteSync(sync);
+    d_3_2_Core->f.DeleteSync(sync);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsSync(GLsync sync)
 {
-    return d_3_2_Core->IsSync(sync);
+    return d_3_2_Core->f.IsSync(sync);
 }
 
 inline GLsync QOpenGLFunctions_4_0_Compatibility::glFenceSync(GLenum condition, GLbitfield flags)
 {
-    return d_3_2_Core->FenceSync(condition, flags);
+    return d_3_2_Core->f.FenceSync(condition, flags);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glProvokingVertex(GLenum mode)
 {
-    d_3_2_Core->ProvokingVertex(mode);
+    d_3_2_Core->f.ProvokingVertex(mode);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
 {
-    d_3_2_Core->MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
-    d_3_2_Core->FramebufferTexture(target, attachment, texture, level);
+    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetBufferParameteri64v(target, pname, params);
+    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64i_v(target, index, data);
+    d_3_2_Core->f.GetInteger64i_v(target, index, data);
 }
 
 
 // OpenGL 3.3 core functions
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP4uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP4ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP3uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP3ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP2uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP2ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP1uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP1ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->SecondaryColorP3uiv(type, color);
+    d_3_3_Deprecated->f.SecondaryColorP3uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->SecondaryColorP3ui(type, color);
+    d_3_3_Deprecated->f.SecondaryColorP3ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->ColorP4uiv(type, color);
+    d_3_3_Deprecated->f.ColorP4uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColorP4ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->ColorP4ui(type, color);
+    d_3_3_Deprecated->f.ColorP4ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->ColorP3uiv(type, color);
+    d_3_3_Deprecated->f.ColorP3uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColorP3ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->ColorP3ui(type, color);
+    d_3_3_Deprecated->f.ColorP3ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->NormalP3uiv(type, coords);
+    d_3_3_Deprecated->f.NormalP3uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->NormalP3ui(type, coords);
+    d_3_3_Deprecated->f.NormalP3ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP4uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP4uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP4ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP4ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP3uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP3uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP3ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP3ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP2uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP2uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP2ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP2ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP1uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP1uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP1ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP1ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP4uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP4uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP4ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP4ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP3uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP3uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP3ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP3ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP2uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP2uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP2ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP2ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP1uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP1uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP1ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP1ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP4uiv(type, value);
+    d_3_3_Deprecated->f.VertexP4uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexP4ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP4ui(type, value);
+    d_3_3_Deprecated->f.VertexP4ui(type, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP3uiv(type, value);
+    d_3_3_Deprecated->f.VertexP3uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexP3ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP3ui(type, value);
+    d_3_3_Deprecated->f.VertexP3ui(type, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP2uiv(type, value);
+    d_3_3_Deprecated->f.VertexP2uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexP2ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP2ui(type, value);
+    d_3_3_Deprecated->f.VertexP2ui(type, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
 {
-    d_3_3_Core->GetQueryObjectui64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
 {
-    d_3_3_Core->GetQueryObjecti64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glQueryCounter(GLuint id, GLenum target)
 {
-    d_3_3_Core->QueryCounter(id, target);
+    d_3_3_Core->f.QueryCounter(id, target);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
 {
-    d_3_3_Core->GetSamplerParameterIuiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
 {
-    d_3_3_Core->GetSamplerParameterfv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameterIiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameteriv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
 {
-    d_3_3_Core->SamplerParameterIuiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameterIiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
 {
-    d_3_3_Core->SamplerParameterfv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
 {
-    d_3_3_Core->SamplerParameterf(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameteriv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
-    d_3_3_Core->SamplerParameteri(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBindSampler(GLuint unit, GLuint sampler)
 {
-    d_3_3_Core->BindSampler(unit, sampler);
+    d_3_3_Core->f.BindSampler(unit, sampler);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsSampler(GLuint sampler)
 {
-    return d_3_3_Core->IsSampler(sampler);
+    return d_3_3_Core->f.IsSampler(sampler);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDeleteSamplers(GLsizei count, const GLuint *samplers)
 {
-    d_3_3_Core->DeleteSamplers(count, samplers);
+    d_3_3_Core->f.DeleteSamplers(count, samplers);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGenSamplers(GLsizei count, GLuint *samplers)
 {
-    d_3_3_Core->GenSamplers(count, samplers);
+    d_3_3_Core->f.GenSamplers(count, samplers);
 }
 
 inline GLint QOpenGLFunctions_4_0_Compatibility::glGetFragDataIndex(GLuint program, const GLchar *name)
 {
-    return d_3_3_Core->GetFragDataIndex(program, name);
+    return d_3_3_Core->f.GetFragDataIndex(program, name);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
 {
-    d_3_3_Core->BindFragDataLocationIndexed(program, colorNumber, index, name);
+    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribDivisor(GLuint index, GLuint divisor)
 {
-    d_3_3_Core->VertexAttribDivisor(index, divisor);
+    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
 }
 
 
 // OpenGL 4.0 core functions
 inline void QOpenGLFunctions_4_0_Compatibility::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
 {
-    d_4_0_Core->GetQueryIndexediv(target, index, pname, params);
+    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEndQueryIndexed(GLenum target, GLuint index)
 {
-    d_4_0_Core->EndQueryIndexed(target, index);
+    d_4_0_Core->f.EndQueryIndexed(target, index);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
 {
-    d_4_0_Core->BeginQueryIndexed(target, index, id);
+    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
 {
-    d_4_0_Core->DrawTransformFeedbackStream(mode, id, stream);
+    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDrawTransformFeedback(GLenum mode, GLuint id)
 {
-    d_4_0_Core->DrawTransformFeedback(mode, id);
+    d_4_0_Core->f.DrawTransformFeedback(mode, id);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glResumeTransformFeedback()
 {
-    d_4_0_Core->ResumeTransformFeedback();
+    d_4_0_Core->f.ResumeTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPauseTransformFeedback()
 {
-    d_4_0_Core->PauseTransformFeedback();
+    d_4_0_Core->f.PauseTransformFeedback();
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsTransformFeedback(GLuint id)
 {
-    return d_4_0_Core->IsTransformFeedback(id);
+    return d_4_0_Core->f.IsTransformFeedback(id);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
 {
-    d_4_0_Core->GenTransformFeedbacks(n, ids);
+    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
 {
-    d_4_0_Core->DeleteTransformFeedbacks(n, ids);
+    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBindTransformFeedback(GLenum target, GLuint id)
 {
-    d_4_0_Core->BindTransformFeedback(target, id);
+    d_4_0_Core->f.BindTransformFeedback(target, id);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPatchParameterfv(GLenum pname, const GLfloat *values)
 {
-    d_4_0_Core->PatchParameterfv(pname, values);
+    d_4_0_Core->f.PatchParameterfv(pname, values);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPatchParameteri(GLenum pname, GLint value)
 {
-    d_4_0_Core->PatchParameteri(pname, value);
+    d_4_0_Core->f.PatchParameteri(pname, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetProgramStageiv(program, shadertype, pname, values);
+    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
 {
-    d_4_0_Core->GetUniformSubroutineuiv(shadertype, location, params);
+    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
 {
-    d_4_0_Core->UniformSubroutinesuiv(shadertype, count, indices);
+    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
+    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
 }
 
 inline GLuint QOpenGLFunctions_4_0_Compatibility::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineIndex(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
 }
 
 inline GLint QOpenGLFunctions_4_0_Compatibility::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineUniformLocation(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
 {
-    d_4_0_Core->GetUniformdv(program, location, params);
+    d_4_0_Core->f.GetUniformdv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform4dv(location, count, value);
+    d_4_0_Core->f.Uniform4dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform3dv(location, count, value);
+    d_4_0_Core->f.Uniform3dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform2dv(location, count, value);
+    d_4_0_Core->f.Uniform2dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform1dv(location, count, value);
+    d_4_0_Core->f.Uniform1dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_0_Core->Uniform4d(location, x, y, z, w);
+    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_0_Core->Uniform3d(location, x, y, z);
+    d_4_0_Core->f.Uniform3d(location, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform2d(GLint location, GLdouble x, GLdouble y)
 {
-    d_4_0_Core->Uniform2d(location, x, y);
+    d_4_0_Core->f.Uniform2d(location, x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glUniform1d(GLint location, GLdouble x)
 {
-    d_4_0_Core->Uniform1d(location, x);
+    d_4_0_Core->f.Uniform1d(location, x);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
 {
-    d_4_0_Core->DrawElementsIndirect(mode, type, indirect);
+    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDrawArraysIndirect(GLenum mode, const GLvoid *indirect)
 {
-    d_4_0_Core->DrawArraysIndirect(mode, indirect);
+    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-    d_4_0_Core->BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
 {
-    d_4_0_Core->BlendFunci(buf, src, dst);
+    d_4_0_Core->f.BlendFunci(buf, src, dst);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
 {
-    d_4_0_Core->BlendEquationSeparatei(buf, modeRGB, modeAlpha);
+    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBlendEquationi(GLuint buf, GLenum mode)
 {
-    d_4_0_Core->BlendEquationi(buf, mode);
+    d_4_0_Core->f.BlendEquationi(buf, mode);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMinSampleShading(GLfloat value)
 {
-    d_4_0_Core->MinSampleShading(value);
+    d_4_0_Core->f.MinSampleShading(value);
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_4_0_Compatibility::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Compatibility::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_4_0_Compatibility::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_4_0_Compatibility::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
 // OpenGL 1.1 deprecated functions
 inline void QOpenGLFunctions_4_0_Compatibility::glPushClientAttrib(GLbitfield mask)
 {
-    d_1_1_Deprecated->PushClientAttrib(mask);
+    d_1_1_Deprecated->f.PushClientAttrib(mask);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPopClientAttrib()
 {
-    d_1_1_Deprecated->PopClientAttrib();
+    d_1_1_Deprecated->f.PopClientAttrib();
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 {
-    d_1_1_Deprecated->PrioritizeTextures(n, textures, priorities);
+    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Compatibility::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-    return d_1_1_Deprecated->AreTexturesResident(n, textures, residences);
+    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->VertexPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->TexCoordPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->NormalPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->InterleavedArrays(format, stride, pointer);
+    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->IndexPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEnableClientState(GLenum array)
 {
-    d_1_1_Deprecated->EnableClientState(array);
+    d_1_1_Deprecated->f.EnableClientState(array);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->EdgeFlagPointer(stride, pointer);
+    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glDisableClientState(GLenum array)
 {
-    d_1_1_Deprecated->DisableClientState(array);
+    d_1_1_Deprecated->f.DisableClientState(array);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->ColorPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glArrayElement(GLint i)
 {
-    d_1_1_Deprecated->ArrayElement(i);
+    d_1_1_Deprecated->f.ArrayElement(i);
 }
 
 
 // OpenGL 1.2 deprecated functions
 inline void QOpenGLFunctions_4_0_Compatibility::glResetMinmax(GLenum target)
 {
-    d_1_2_Deprecated->ResetMinmax(target);
+    d_1_2_Deprecated->f.ResetMinmax(target);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glResetHistogram(GLenum target)
 {
-    d_1_2_Deprecated->ResetHistogram(target);
+    d_1_2_Deprecated->f.ResetHistogram(target);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Minmax(target, internalformat, sink);
+    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Histogram(target, width, internalformat, sink);
+    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetMinmax(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetHistogramParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetHistogramParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetHistogram(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
 {
-    d_1_2_Deprecated->SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
+    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
 {
-    d_1_2_Deprecated->GetSeparableFilter(target, format, type, row, column, span);
+    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
 {
-    d_1_2_Deprecated->GetConvolutionFilter(target, format, type, image);
+    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
+    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter1D(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
 {
-    d_1_2_Deprecated->ConvolutionParameteri(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
 {
-    d_1_2_Deprecated->ConvolutionParameterf(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter1D(target, internalformat, width, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorSubTable(target, start, x, y, width);
+    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
 {
-    d_1_2_Deprecated->ColorSubTable(target, start, count, format, type, data);
+    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
 {
-    d_1_2_Deprecated->GetColorTable(target, format, type, table);
+    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorTable(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
 {
-    d_1_2_Deprecated->ColorTable(target, internalformat, width, format, type, table);
+    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
 }
 
 
 // OpenGL 1.3 deprecated functions
 inline void QOpenGLFunctions_4_0_Compatibility::glMultTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixd(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixf(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLoadTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixd(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glLoadTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixf(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord4sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_3_Deprecated->MultiTexCoord4s(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord4iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_3_Deprecated->MultiTexCoord4i(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_3_Deprecated->MultiTexCoord4f(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_3_Deprecated->MultiTexCoord4d(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord3sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
 {
-    d_1_3_Deprecated->MultiTexCoord3s(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord3iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
 {
-    d_1_3_Deprecated->MultiTexCoord3i(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_3_Deprecated->MultiTexCoord3f(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_3_Deprecated->MultiTexCoord3d(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord2sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
 {
-    d_1_3_Deprecated->MultiTexCoord2s(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord2iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
 {
-    d_1_3_Deprecated->MultiTexCoord2i(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
 {
-    d_1_3_Deprecated->MultiTexCoord2f(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
 {
-    d_1_3_Deprecated->MultiTexCoord2d(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord1sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord1s(GLenum target, GLshort s)
 {
-    d_1_3_Deprecated->MultiTexCoord1s(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord1iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord1i(GLenum target, GLint s)
 {
-    d_1_3_Deprecated->MultiTexCoord1i(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord1f(GLenum target, GLfloat s)
 {
-    d_1_3_Deprecated->MultiTexCoord1f(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glMultiTexCoord1d(GLenum target, GLdouble s)
 {
-    d_1_3_Deprecated->MultiTexCoord1d(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glClientActiveTexture(GLenum texture)
 {
-    d_1_3_Deprecated->ClientActiveTexture(texture);
+    d_1_3_Deprecated->f.ClientActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 deprecated functions
 inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos3sv(v);
+    d_1_4_Deprecated->f.WindowPos3sv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_4_Deprecated->WindowPos3s(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos3iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos3iv(v);
+    d_1_4_Deprecated->f.WindowPos3iv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_4_Deprecated->WindowPos3i(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos3fv(v);
+    d_1_4_Deprecated->f.WindowPos3fv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_4_Deprecated->WindowPos3f(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos3dv(v);
+    d_1_4_Deprecated->f.WindowPos3dv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_4_Deprecated->WindowPos3d(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos2sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos2sv(v);
+    d_1_4_Deprecated->f.WindowPos2sv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos2s(GLshort x, GLshort y)
 {
-    d_1_4_Deprecated->WindowPos2s(x, y);
+    d_1_4_Deprecated->f.WindowPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos2iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos2iv(v);
+    d_1_4_Deprecated->f.WindowPos2iv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos2i(GLint x, GLint y)
 {
-    d_1_4_Deprecated->WindowPos2i(x, y);
+    d_1_4_Deprecated->f.WindowPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos2fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos2fv(v);
+    d_1_4_Deprecated->f.WindowPos2fv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos2f(GLfloat x, GLfloat y)
 {
-    d_1_4_Deprecated->WindowPos2f(x, y);
+    d_1_4_Deprecated->f.WindowPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos2dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos2dv(v);
+    d_1_4_Deprecated->f.WindowPos2dv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glWindowPos2d(GLdouble x, GLdouble y)
 {
-    d_1_4_Deprecated->WindowPos2d(x, y);
+    d_1_4_Deprecated->f.WindowPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->SecondaryColorPointer(size, type, stride, pointer);
+    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3usv(const GLushort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3usv(v);
+    d_1_4_Deprecated->f.SecondaryColor3usv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3us(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3uiv(const GLuint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3uiv(v);
+    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ui(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3ubv(const GLubyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3ubv(v);
+    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ub(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3sv(v);
+    d_1_4_Deprecated->f.SecondaryColor3sv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3s(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3iv(const GLint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3iv(v);
+    d_1_4_Deprecated->f.SecondaryColor3iv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3i(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->SecondaryColor3fv(v);
+    d_1_4_Deprecated->f.SecondaryColor3fv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_4_Deprecated->SecondaryColor3f(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->SecondaryColor3dv(v);
+    d_1_4_Deprecated->f.SecondaryColor3dv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_4_Deprecated->SecondaryColor3d(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3bv(const GLbyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3bv(v);
+    d_1_4_Deprecated->f.SecondaryColor3bv(v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3b(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->FogCoordPointer(type, stride, pointer);
+    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFogCoorddv(const GLdouble *coord)
 {
-    d_1_4_Deprecated->FogCoorddv(coord);
+    d_1_4_Deprecated->f.FogCoorddv(coord);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFogCoordd(GLdouble coord)
 {
-    d_1_4_Deprecated->FogCoordd(coord);
+    d_1_4_Deprecated->f.FogCoordd(coord);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFogCoordfv(const GLfloat *coord)
 {
-    d_1_4_Deprecated->FogCoordfv(coord);
+    d_1_4_Deprecated->f.FogCoordfv(coord);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glFogCoordf(GLfloat coord)
 {
-    d_1_4_Deprecated->FogCoordf(coord);
+    d_1_4_Deprecated->f.FogCoordf(coord);
 }
 
 
@@ -4719,182 +4720,182 @@ inline void QOpenGLFunctions_4_0_Compatibility::glFogCoordf(GLfloat coord)
 // OpenGL 2.0 deprecated functions
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4usv(index, v);
+    d_2_0_Core->f.VertexAttrib4usv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4uiv(index, v);
+    d_2_0_Core->f.VertexAttrib4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4ubv(index, v);
+    d_2_0_Core->f.VertexAttrib4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4sv(index, v);
+    d_2_0_Core->f.VertexAttrib4sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4iv(index, v);
+    d_2_0_Core->f.VertexAttrib4iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib4fv(index, v);
+    d_2_0_Core->f.VertexAttrib4fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib4dv(index, v);
+    d_2_0_Core->f.VertexAttrib4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4bv(index, v);
+    d_2_0_Core->f.VertexAttrib4bv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4Nusv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4Nuiv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nubv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
 {
-    d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4Nsv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4Niv(index, v);
+    d_2_0_Core->f.VertexAttrib4Niv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nbv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib3sv(index, v);
+    d_2_0_Core->f.VertexAttrib3sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
 {
-    d_2_0_Core->VertexAttrib3s(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib3fv(index, v);
+    d_2_0_Core->f.VertexAttrib3fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_2_0_Core->VertexAttrib3f(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib3dv(index, v);
+    d_2_0_Core->f.VertexAttrib3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_2_0_Core->VertexAttrib3d(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib2sv(index, v);
+    d_2_0_Core->f.VertexAttrib2sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
 {
-    d_2_0_Core->VertexAttrib2s(index, x, y);
+    d_2_0_Core->f.VertexAttrib2s(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib2fv(index, v);
+    d_2_0_Core->f.VertexAttrib2fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
 {
-    d_2_0_Core->VertexAttrib2f(index, x, y);
+    d_2_0_Core->f.VertexAttrib2f(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib2dv(index, v);
+    d_2_0_Core->f.VertexAttrib2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_2_0_Core->VertexAttrib2d(index, x, y);
+    d_2_0_Core->f.VertexAttrib2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib1sv(index, v);
+    d_2_0_Core->f.VertexAttrib1sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
 {
-    d_2_0_Core->VertexAttrib1s(index, x);
+    d_2_0_Core->f.VertexAttrib1s(index, x);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib1fv(index, v);
+    d_2_0_Core->f.VertexAttrib1fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
 {
-    d_2_0_Core->VertexAttrib1f(index, x);
+    d_2_0_Core->f.VertexAttrib1f(index, x);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib1dv(index, v);
+    d_2_0_Core->f.VertexAttrib1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
 {
-    d_2_0_Core->VertexAttrib1d(index, x);
+    d_2_0_Core->f.VertexAttrib1d(index, x);
 }
 
 
@@ -4903,102 +4904,102 @@ inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttrib1d(GLuint index, G
 // OpenGL 3.0 deprecated functions
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
 {
-    d_3_0_Core->VertexAttribI4usv(index, v);
+    d_3_0_Core->f.VertexAttribI4usv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
 {
-    d_3_0_Core->VertexAttribI4ubv(index, v);
+    d_3_0_Core->f.VertexAttribI4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
 {
-    d_3_0_Core->VertexAttribI4sv(index, v);
+    d_3_0_Core->f.VertexAttribI4sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
 {
-    d_3_0_Core->VertexAttribI4bv(index, v);
+    d_3_0_Core->f.VertexAttribI4bv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI4uiv(index, v);
+    d_3_0_Core->f.VertexAttribI4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI3uiv(index, v);
+    d_3_0_Core->f.VertexAttribI3uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI2uiv(index, v);
+    d_3_0_Core->f.VertexAttribI2uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI1uiv(index, v);
+    d_3_0_Core->f.VertexAttribI1uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI4iv(index, v);
+    d_3_0_Core->f.VertexAttribI4iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI3iv(index, v);
+    d_3_0_Core->f.VertexAttribI3iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI2iv(index, v);
+    d_3_0_Core->f.VertexAttribI2iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI1iv(index, v);
+    d_3_0_Core->f.VertexAttribI1iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
 {
-    d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
 {
-    d_3_0_Core->VertexAttribI3ui(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
 {
-    d_3_0_Core->VertexAttribI2ui(index, x, y);
+    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
 {
-    d_3_0_Core->VertexAttribI1ui(index, x);
+    d_3_0_Core->f.VertexAttribI1ui(index, x);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
 {
-    d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
 {
-    d_3_0_Core->VertexAttribI3i(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
 {
-    d_3_0_Core->VertexAttribI2i(index, x, y);
+    d_3_0_Core->f.VertexAttribI2i(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
 {
-    d_3_0_Core->VertexAttribI1i(index, x);
+    d_3_0_Core->f.VertexAttribI1i(index, x);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_4_0_core.cpp b/src/gui/opengl/qopenglfunctions_4_0_core.cpp
index 022a27ccd62..6dc94153c82 100644
--- a/src/gui/opengl/qopenglfunctions_4_0_core.cpp
+++ b/src/gui/opengl/qopenglfunctions_4_0_core.cpp
@@ -85,58 +85,45 @@ QOpenGLFunctions_4_0_Core::QOpenGLFunctions_4_0_Core()
 
 QOpenGLFunctions_4_0_Core::~QOpenGLFunctions_4_0_Core()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
-    if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        delete d_3_2_Core;
-    }
-    if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        delete d_3_3_Core;
-    }
-    if (d_4_0_Core && !d_4_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_0_Core->context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        delete d_4_0_Core;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
+    if (d_3_2_Core)
+        d_3_2_Core->refs.deref();
+    Q_ASSERT(d_3_2_Core->refs.load());
+    if (d_3_3_Core)
+        d_3_3_Core->refs.deref();
+    Q_ASSERT(d_3_3_Core->refs.load());
+    if (d_4_0_Core)
+        d_4_0_Core->refs.deref();
+    Q_ASSERT(d_4_0_Core->refs.load());
 }
 
 bool QOpenGLFunctions_4_0_Core::initializeOpenGLFunctions()
@@ -155,106 +142,54 @@ bool QOpenGLFunctions_4_0_Core::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
-        }
         d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
-        }
         d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus(), d);
-        }
         d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_4_0_core.h b/src/gui/opengl/qopenglfunctions_4_0_core.h
index bd6093d7b03..c3e1e9ce5ab 100644
--- a/src/gui/opengl/qopenglfunctions_4_0_core.h
+++ b/src/gui/opengl/qopenglfunctions_4_0_core.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -483,242 +484,242 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_4_0_Core::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Core::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_0_Core::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_4_0_Core::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_4_0_Core::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_4_0_Core::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
@@ -737,57 +738,57 @@ inline void QOpenGLFunctions_4_0_Core::glIndexub(GLubyte c)
 
 inline GLboolean QOpenGLFunctions_4_0_Core::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetPointerv(GLenum pname, GLvoid* *params)
@@ -799,1067 +800,1067 @@ inline void QOpenGLFunctions_4_0_Core::glGetPointerv(GLenum pname, GLvoid* *para
 
 inline void QOpenGLFunctions_4_0_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_4_0_Core::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_4_0_Core::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_4_0_Core::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_4_0_Core::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Core::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_4_0_Core::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Core::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Core::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_4_0_Core::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Core::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Core::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_4_0_Core::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_4_0_Core::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, obj);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_4_0_Core::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_4_0_Core::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_4_0_Core::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_4_0_Core::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline GLvoid* QOpenGLFunctions_4_0_Core::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_4_0_Core::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Core::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Core::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_0_Core::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_4_0_Core::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Core::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_4_0_Core::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_4_0_Core::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
 // OpenGL 3.2 core functions
 inline void QOpenGLFunctions_4_0_Core::glSampleMaski(GLuint index, GLbitfield mask)
 {
-    d_3_2_Core->SampleMaski(index, mask);
+    d_3_2_Core->f.SampleMaski(index, mask);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
 {
-    d_3_2_Core->GetMultisamplefv(pname, index, val);
+    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
-    d_3_2_Core->GetSynciv(sync, pname, bufSize, length, values);
+    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetInteger64v(GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetInteger64v(pname, params);
+    d_3_2_Core->f.GetInteger64v(pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    d_3_2_Core->WaitSync(sync, flags, timeout);
+    d_3_2_Core->f.WaitSync(sync, flags, timeout);
 }
 
 inline GLenum QOpenGLFunctions_4_0_Core::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    return d_3_2_Core->ClientWaitSync(sync, flags, timeout);
+    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDeleteSync(GLsync sync)
 {
-    d_3_2_Core->DeleteSync(sync);
+    d_3_2_Core->f.DeleteSync(sync);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Core::glIsSync(GLsync sync)
 {
-    return d_3_2_Core->IsSync(sync);
+    return d_3_2_Core->f.IsSync(sync);
 }
 
 inline GLsync QOpenGLFunctions_4_0_Core::glFenceSync(GLenum condition, GLbitfield flags)
 {
-    return d_3_2_Core->FenceSync(condition, flags);
+    return d_3_2_Core->f.FenceSync(condition, flags);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glProvokingVertex(GLenum mode)
 {
-    d_3_2_Core->ProvokingVertex(mode);
+    d_3_2_Core->f.ProvokingVertex(mode);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
 {
-    d_3_2_Core->MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
-    d_3_2_Core->FramebufferTexture(target, attachment, texture, level);
+    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetBufferParameteri64v(target, pname, params);
+    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64i_v(target, index, data);
+    d_3_2_Core->f.GetInteger64i_v(target, index, data);
 }
 
 
 // OpenGL 3.3 core functions
 inline void QOpenGLFunctions_4_0_Core::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP4uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP4ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP3uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP3ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP2uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP2ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP1uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP1ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
@@ -2082,334 +2083,334 @@ inline void QOpenGLFunctions_4_0_Core::glVertexP2ui(GLenum type, GLuint value)
 
 inline void QOpenGLFunctions_4_0_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
 {
-    d_3_3_Core->GetQueryObjectui64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
 {
-    d_3_3_Core->GetQueryObjecti64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glQueryCounter(GLuint id, GLenum target)
 {
-    d_3_3_Core->QueryCounter(id, target);
+    d_3_3_Core->f.QueryCounter(id, target);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
 {
-    d_3_3_Core->GetSamplerParameterIuiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
 {
-    d_3_3_Core->GetSamplerParameterfv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameterIiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameteriv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
 {
-    d_3_3_Core->SamplerParameterIuiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameterIiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
 {
-    d_3_3_Core->SamplerParameterfv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
 {
-    d_3_3_Core->SamplerParameterf(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameteriv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
-    d_3_3_Core->SamplerParameteri(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBindSampler(GLuint unit, GLuint sampler)
 {
-    d_3_3_Core->BindSampler(unit, sampler);
+    d_3_3_Core->f.BindSampler(unit, sampler);
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Core::glIsSampler(GLuint sampler)
 {
-    return d_3_3_Core->IsSampler(sampler);
+    return d_3_3_Core->f.IsSampler(sampler);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDeleteSamplers(GLsizei count, const GLuint *samplers)
 {
-    d_3_3_Core->DeleteSamplers(count, samplers);
+    d_3_3_Core->f.DeleteSamplers(count, samplers);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGenSamplers(GLsizei count, GLuint *samplers)
 {
-    d_3_3_Core->GenSamplers(count, samplers);
+    d_3_3_Core->f.GenSamplers(count, samplers);
 }
 
 inline GLint QOpenGLFunctions_4_0_Core::glGetFragDataIndex(GLuint program, const GLchar *name)
 {
-    return d_3_3_Core->GetFragDataIndex(program, name);
+    return d_3_3_Core->f.GetFragDataIndex(program, name);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
 {
-    d_3_3_Core->BindFragDataLocationIndexed(program, colorNumber, index, name);
+    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glVertexAttribDivisor(GLuint index, GLuint divisor)
 {
-    d_3_3_Core->VertexAttribDivisor(index, divisor);
+    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
 }
 
 
 // OpenGL 4.0 core functions
 inline void QOpenGLFunctions_4_0_Core::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
 {
-    d_4_0_Core->GetQueryIndexediv(target, index, pname, params);
+    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glEndQueryIndexed(GLenum target, GLuint index)
 {
-    d_4_0_Core->EndQueryIndexed(target, index);
+    d_4_0_Core->f.EndQueryIndexed(target, index);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
 {
-    d_4_0_Core->BeginQueryIndexed(target, index, id);
+    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
 {
-    d_4_0_Core->DrawTransformFeedbackStream(mode, id, stream);
+    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDrawTransformFeedback(GLenum mode, GLuint id)
 {
-    d_4_0_Core->DrawTransformFeedback(mode, id);
+    d_4_0_Core->f.DrawTransformFeedback(mode, id);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glResumeTransformFeedback()
 {
-    d_4_0_Core->ResumeTransformFeedback();
+    d_4_0_Core->f.ResumeTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_0_Core::glPauseTransformFeedback()
 {
-    d_4_0_Core->PauseTransformFeedback();
+    d_4_0_Core->f.PauseTransformFeedback();
 }
 
 inline GLboolean QOpenGLFunctions_4_0_Core::glIsTransformFeedback(GLuint id)
 {
-    return d_4_0_Core->IsTransformFeedback(id);
+    return d_4_0_Core->f.IsTransformFeedback(id);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
 {
-    d_4_0_Core->GenTransformFeedbacks(n, ids);
+    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
 {
-    d_4_0_Core->DeleteTransformFeedbacks(n, ids);
+    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBindTransformFeedback(GLenum target, GLuint id)
 {
-    d_4_0_Core->BindTransformFeedback(target, id);
+    d_4_0_Core->f.BindTransformFeedback(target, id);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glPatchParameterfv(GLenum pname, const GLfloat *values)
 {
-    d_4_0_Core->PatchParameterfv(pname, values);
+    d_4_0_Core->f.PatchParameterfv(pname, values);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glPatchParameteri(GLenum pname, GLint value)
 {
-    d_4_0_Core->PatchParameteri(pname, value);
+    d_4_0_Core->f.PatchParameteri(pname, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetProgramStageiv(program, shadertype, pname, values);
+    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
 {
-    d_4_0_Core->GetUniformSubroutineuiv(shadertype, location, params);
+    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
 {
-    d_4_0_Core->UniformSubroutinesuiv(shadertype, count, indices);
+    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
+    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
 }
 
 inline GLuint QOpenGLFunctions_4_0_Core::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineIndex(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
 }
 
 inline GLint QOpenGLFunctions_4_0_Core::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineUniformLocation(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
 {
-    d_4_0_Core->GetUniformdv(program, location, params);
+    d_4_0_Core->f.GetUniformdv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform4dv(location, count, value);
+    d_4_0_Core->f.Uniform4dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform3dv(location, count, value);
+    d_4_0_Core->f.Uniform3dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform2dv(location, count, value);
+    d_4_0_Core->f.Uniform2dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform1dv(location, count, value);
+    d_4_0_Core->f.Uniform1dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_0_Core->Uniform4d(location, x, y, z, w);
+    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_0_Core->Uniform3d(location, x, y, z);
+    d_4_0_Core->f.Uniform3d(location, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform2d(GLint location, GLdouble x, GLdouble y)
 {
-    d_4_0_Core->Uniform2d(location, x, y);
+    d_4_0_Core->f.Uniform2d(location, x, y);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glUniform1d(GLint location, GLdouble x)
 {
-    d_4_0_Core->Uniform1d(location, x);
+    d_4_0_Core->f.Uniform1d(location, x);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
 {
-    d_4_0_Core->DrawElementsIndirect(mode, type, indirect);
+    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glDrawArraysIndirect(GLenum mode, const GLvoid *indirect)
 {
-    d_4_0_Core->DrawArraysIndirect(mode, indirect);
+    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-    d_4_0_Core->BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
 {
-    d_4_0_Core->BlendFunci(buf, src, dst);
+    d_4_0_Core->f.BlendFunci(buf, src, dst);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
 {
-    d_4_0_Core->BlendEquationSeparatei(buf, modeRGB, modeAlpha);
+    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glBlendEquationi(GLuint buf, GLenum mode)
 {
-    d_4_0_Core->BlendEquationi(buf, mode);
+    d_4_0_Core->f.BlendEquationi(buf, mode);
 }
 
 inline void QOpenGLFunctions_4_0_Core::glMinSampleShading(GLfloat value)
 {
-    d_4_0_Core->MinSampleShading(value);
+    d_4_0_Core->f.MinSampleShading(value);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_4_1_compatibility.cpp b/src/gui/opengl/qopenglfunctions_4_1_compatibility.cpp
index f1a3bb5b059..293409ddef1 100644
--- a/src/gui/opengl/qopenglfunctions_4_1_compatibility.cpp
+++ b/src/gui/opengl/qopenglfunctions_4_1_compatibility.cpp
@@ -93,86 +93,66 @@ QOpenGLFunctions_4_1_Compatibility::QOpenGLFunctions_4_1_Compatibility()
 
 QOpenGLFunctions_4_1_Compatibility::~QOpenGLFunctions_4_1_Compatibility()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
-    if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        delete d_3_2_Core;
-    }
-    if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        delete d_3_3_Core;
-    }
-    if (d_4_0_Core && !d_4_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_0_Core->context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        delete d_4_0_Core;
-    }
-    if (d_4_1_Core && !d_4_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_1_Core->context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        delete d_4_1_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
-    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        delete d_1_1_Deprecated;
-    }
-    if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        delete d_1_2_Deprecated;
-    }
-    if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        delete d_1_3_Deprecated;
-    }
-    if (d_1_4_Deprecated && !d_1_4_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        delete d_1_4_Deprecated;
-    }
-    if (d_3_3_Deprecated && !d_3_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Deprecated->context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        delete d_3_3_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
+    if (d_3_2_Core)
+        d_3_2_Core->refs.deref();
+    Q_ASSERT(d_3_2_Core->refs.load());
+    if (d_3_3_Core)
+        d_3_3_Core->refs.deref();
+    Q_ASSERT(d_3_3_Core->refs.load());
+    if (d_4_0_Core)
+        d_4_0_Core->refs.deref();
+    Q_ASSERT(d_4_0_Core->refs.load());
+    if (d_4_1_Core)
+        d_4_1_Core->refs.deref();
+    Q_ASSERT(d_4_1_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
+    if (d_1_1_Deprecated)
+        d_1_1_Deprecated->refs.deref();
+    Q_ASSERT(d_1_1_Deprecated->refs.load());
+    if (d_1_2_Deprecated)
+        d_1_2_Deprecated->refs.deref();
+    Q_ASSERT(d_1_2_Deprecated->refs.load());
+    if (d_1_3_Deprecated)
+        d_1_3_Deprecated->refs.deref();
+    Q_ASSERT(d_1_3_Deprecated->refs.load());
+    if (d_1_4_Deprecated)
+        d_1_4_Deprecated->refs.deref();
+    Q_ASSERT(d_1_4_Deprecated->refs.load());
+    if (d_3_3_Deprecated)
+        d_3_3_Deprecated->refs.deref();
+    Q_ASSERT(d_3_3_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_4_1_Compatibility::initializeOpenGLFunctions()
@@ -191,162 +171,82 @@ bool QOpenGLFunctions_4_1_Compatibility::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
-        }
         d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
-        }
         d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus(), d);
-        }
         d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus(), d);
-        }
         d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_4_1_compatibility.h b/src/gui/opengl/qopenglfunctions_4_1_compatibility.h
index 17d87446c20..e06803f0aa1 100644
--- a/src/gui/opengl/qopenglfunctions_4_1_compatibility.h
+++ b/src/gui/opengl/qopenglfunctions_4_1_compatibility.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -1044,4208 +1045,4208 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_4_1_Compatibility::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_1_Compatibility::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_4_1_Compatibility::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline void QOpenGLFunctions_4_1_Compatibility::glIndexubv(const GLubyte *c)
 {
-    d_1_1_Deprecated->Indexubv(c);
+    d_1_1_Deprecated->f.Indexubv(c);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glIndexub(GLubyte c)
 {
-    d_1_1_Deprecated->Indexub(c);
+    d_1_1_Deprecated->f.Indexub(c);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
 {
-    d_1_1_Deprecated->GetPointerv(pname, params);
+    d_1_1_Deprecated->f.GetPointerv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_4_1_Compatibility::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_4_1_Compatibility::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_4_1_Compatibility::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_4_1_Compatibility::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_4_1_Compatibility::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_4_1_Compatibility::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_4_1_Compatibility::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, obj);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_4_1_Compatibility::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_4_1_Compatibility::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline GLvoid* QOpenGLFunctions_4_1_Compatibility::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_4_1_Compatibility::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_1_Compatibility::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_4_1_Compatibility::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_4_1_Compatibility::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_4_1_Compatibility::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
 // OpenGL 3.2 core functions
 inline void QOpenGLFunctions_4_1_Compatibility::glSampleMaski(GLuint index, GLbitfield mask)
 {
-    d_3_2_Core->SampleMaski(index, mask);
+    d_3_2_Core->f.SampleMaski(index, mask);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
 {
-    d_3_2_Core->GetMultisamplefv(pname, index, val);
+    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
-    d_3_2_Core->GetSynciv(sync, pname, bufSize, length, values);
+    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetInteger64v(GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetInteger64v(pname, params);
+    d_3_2_Core->f.GetInteger64v(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    d_3_2_Core->WaitSync(sync, flags, timeout);
+    d_3_2_Core->f.WaitSync(sync, flags, timeout);
 }
 
 inline GLenum QOpenGLFunctions_4_1_Compatibility::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    return d_3_2_Core->ClientWaitSync(sync, flags, timeout);
+    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDeleteSync(GLsync sync)
 {
-    d_3_2_Core->DeleteSync(sync);
+    d_3_2_Core->f.DeleteSync(sync);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsSync(GLsync sync)
 {
-    return d_3_2_Core->IsSync(sync);
+    return d_3_2_Core->f.IsSync(sync);
 }
 
 inline GLsync QOpenGLFunctions_4_1_Compatibility::glFenceSync(GLenum condition, GLbitfield flags)
 {
-    return d_3_2_Core->FenceSync(condition, flags);
+    return d_3_2_Core->f.FenceSync(condition, flags);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProvokingVertex(GLenum mode)
 {
-    d_3_2_Core->ProvokingVertex(mode);
+    d_3_2_Core->f.ProvokingVertex(mode);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
 {
-    d_3_2_Core->MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
-    d_3_2_Core->FramebufferTexture(target, attachment, texture, level);
+    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetBufferParameteri64v(target, pname, params);
+    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64i_v(target, index, data);
+    d_3_2_Core->f.GetInteger64i_v(target, index, data);
 }
 
 
 // OpenGL 3.3 core functions
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP4uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP4ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP3uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP3ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP2uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP2ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP1uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP1ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->SecondaryColorP3uiv(type, color);
+    d_3_3_Deprecated->f.SecondaryColorP3uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->SecondaryColorP3ui(type, color);
+    d_3_3_Deprecated->f.SecondaryColorP3ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->ColorP4uiv(type, color);
+    d_3_3_Deprecated->f.ColorP4uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColorP4ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->ColorP4ui(type, color);
+    d_3_3_Deprecated->f.ColorP4ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->ColorP3uiv(type, color);
+    d_3_3_Deprecated->f.ColorP3uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColorP3ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->ColorP3ui(type, color);
+    d_3_3_Deprecated->f.ColorP3ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->NormalP3uiv(type, coords);
+    d_3_3_Deprecated->f.NormalP3uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->NormalP3ui(type, coords);
+    d_3_3_Deprecated->f.NormalP3ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP4uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP4uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP4ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP4ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP3uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP3uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP3ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP3ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP2uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP2uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP2ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP2ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP1uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP1uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP1ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP1ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP4uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP4uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP4ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP4ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP3uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP3uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP3ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP3ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP2uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP2uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP2ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP2ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP1uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP1uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP1ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP1ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP4uiv(type, value);
+    d_3_3_Deprecated->f.VertexP4uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexP4ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP4ui(type, value);
+    d_3_3_Deprecated->f.VertexP4ui(type, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP3uiv(type, value);
+    d_3_3_Deprecated->f.VertexP3uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexP3ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP3ui(type, value);
+    d_3_3_Deprecated->f.VertexP3ui(type, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP2uiv(type, value);
+    d_3_3_Deprecated->f.VertexP2uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexP2ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP2ui(type, value);
+    d_3_3_Deprecated->f.VertexP2ui(type, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
 {
-    d_3_3_Core->GetQueryObjectui64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
 {
-    d_3_3_Core->GetQueryObjecti64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glQueryCounter(GLuint id, GLenum target)
 {
-    d_3_3_Core->QueryCounter(id, target);
+    d_3_3_Core->f.QueryCounter(id, target);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
 {
-    d_3_3_Core->GetSamplerParameterIuiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
 {
-    d_3_3_Core->GetSamplerParameterfv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameterIiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameteriv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
 {
-    d_3_3_Core->SamplerParameterIuiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameterIiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
 {
-    d_3_3_Core->SamplerParameterfv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
 {
-    d_3_3_Core->SamplerParameterf(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameteriv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
-    d_3_3_Core->SamplerParameteri(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBindSampler(GLuint unit, GLuint sampler)
 {
-    d_3_3_Core->BindSampler(unit, sampler);
+    d_3_3_Core->f.BindSampler(unit, sampler);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsSampler(GLuint sampler)
 {
-    return d_3_3_Core->IsSampler(sampler);
+    return d_3_3_Core->f.IsSampler(sampler);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDeleteSamplers(GLsizei count, const GLuint *samplers)
 {
-    d_3_3_Core->DeleteSamplers(count, samplers);
+    d_3_3_Core->f.DeleteSamplers(count, samplers);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGenSamplers(GLsizei count, GLuint *samplers)
 {
-    d_3_3_Core->GenSamplers(count, samplers);
+    d_3_3_Core->f.GenSamplers(count, samplers);
 }
 
 inline GLint QOpenGLFunctions_4_1_Compatibility::glGetFragDataIndex(GLuint program, const GLchar *name)
 {
-    return d_3_3_Core->GetFragDataIndex(program, name);
+    return d_3_3_Core->f.GetFragDataIndex(program, name);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
 {
-    d_3_3_Core->BindFragDataLocationIndexed(program, colorNumber, index, name);
+    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribDivisor(GLuint index, GLuint divisor)
 {
-    d_3_3_Core->VertexAttribDivisor(index, divisor);
+    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
 }
 
 
 // OpenGL 4.0 core functions
 inline void QOpenGLFunctions_4_1_Compatibility::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
 {
-    d_4_0_Core->GetQueryIndexediv(target, index, pname, params);
+    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEndQueryIndexed(GLenum target, GLuint index)
 {
-    d_4_0_Core->EndQueryIndexed(target, index);
+    d_4_0_Core->f.EndQueryIndexed(target, index);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
 {
-    d_4_0_Core->BeginQueryIndexed(target, index, id);
+    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
 {
-    d_4_0_Core->DrawTransformFeedbackStream(mode, id, stream);
+    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDrawTransformFeedback(GLenum mode, GLuint id)
 {
-    d_4_0_Core->DrawTransformFeedback(mode, id);
+    d_4_0_Core->f.DrawTransformFeedback(mode, id);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glResumeTransformFeedback()
 {
-    d_4_0_Core->ResumeTransformFeedback();
+    d_4_0_Core->f.ResumeTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPauseTransformFeedback()
 {
-    d_4_0_Core->PauseTransformFeedback();
+    d_4_0_Core->f.PauseTransformFeedback();
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsTransformFeedback(GLuint id)
 {
-    return d_4_0_Core->IsTransformFeedback(id);
+    return d_4_0_Core->f.IsTransformFeedback(id);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
 {
-    d_4_0_Core->GenTransformFeedbacks(n, ids);
+    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
 {
-    d_4_0_Core->DeleteTransformFeedbacks(n, ids);
+    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBindTransformFeedback(GLenum target, GLuint id)
 {
-    d_4_0_Core->BindTransformFeedback(target, id);
+    d_4_0_Core->f.BindTransformFeedback(target, id);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPatchParameterfv(GLenum pname, const GLfloat *values)
 {
-    d_4_0_Core->PatchParameterfv(pname, values);
+    d_4_0_Core->f.PatchParameterfv(pname, values);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPatchParameteri(GLenum pname, GLint value)
 {
-    d_4_0_Core->PatchParameteri(pname, value);
+    d_4_0_Core->f.PatchParameteri(pname, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetProgramStageiv(program, shadertype, pname, values);
+    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
 {
-    d_4_0_Core->GetUniformSubroutineuiv(shadertype, location, params);
+    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
 {
-    d_4_0_Core->UniformSubroutinesuiv(shadertype, count, indices);
+    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
+    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
 }
 
 inline GLuint QOpenGLFunctions_4_1_Compatibility::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineIndex(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
 }
 
 inline GLint QOpenGLFunctions_4_1_Compatibility::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineUniformLocation(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
 {
-    d_4_0_Core->GetUniformdv(program, location, params);
+    d_4_0_Core->f.GetUniformdv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform4dv(location, count, value);
+    d_4_0_Core->f.Uniform4dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform3dv(location, count, value);
+    d_4_0_Core->f.Uniform3dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform2dv(location, count, value);
+    d_4_0_Core->f.Uniform2dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform1dv(location, count, value);
+    d_4_0_Core->f.Uniform1dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_0_Core->Uniform4d(location, x, y, z, w);
+    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_0_Core->Uniform3d(location, x, y, z);
+    d_4_0_Core->f.Uniform3d(location, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform2d(GLint location, GLdouble x, GLdouble y)
 {
-    d_4_0_Core->Uniform2d(location, x, y);
+    d_4_0_Core->f.Uniform2d(location, x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUniform1d(GLint location, GLdouble x)
 {
-    d_4_0_Core->Uniform1d(location, x);
+    d_4_0_Core->f.Uniform1d(location, x);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
 {
-    d_4_0_Core->DrawElementsIndirect(mode, type, indirect);
+    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDrawArraysIndirect(GLenum mode, const GLvoid *indirect)
 {
-    d_4_0_Core->DrawArraysIndirect(mode, indirect);
+    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-    d_4_0_Core->BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
 {
-    d_4_0_Core->BlendFunci(buf, src, dst);
+    d_4_0_Core->f.BlendFunci(buf, src, dst);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
 {
-    d_4_0_Core->BlendEquationSeparatei(buf, modeRGB, modeAlpha);
+    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBlendEquationi(GLuint buf, GLenum mode)
 {
-    d_4_0_Core->BlendEquationi(buf, mode);
+    d_4_0_Core->f.BlendEquationi(buf, mode);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMinSampleShading(GLfloat value)
 {
-    d_4_0_Core->MinSampleShading(value);
+    d_4_0_Core->f.MinSampleShading(value);
 }
 
 
 // OpenGL 4.1 core functions
 inline void QOpenGLFunctions_4_1_Compatibility::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
 {
-    d_4_1_Core->GetDoublei_v(target, index, data);
+    d_4_1_Core->f.GetDoublei_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
 {
-    d_4_1_Core->GetFloati_v(target, index, data);
+    d_4_1_Core->f.GetFloati_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
 {
-    d_4_1_Core->DepthRangeIndexed(index, n, f);
+    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
 {
-    d_4_1_Core->DepthRangeArrayv(first, count, v);
+    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glScissorIndexedv(GLuint index, const GLint *v)
 {
-    d_4_1_Core->ScissorIndexedv(index, v);
+    d_4_1_Core->f.ScissorIndexedv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
 {
-    d_4_1_Core->ScissorIndexed(index, left, bottom, width, height);
+    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
 {
-    d_4_1_Core->ScissorArrayv(first, count, v);
+    d_4_1_Core->f.ScissorArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glViewportIndexedfv(GLuint index, const GLfloat *v)
 {
-    d_4_1_Core->ViewportIndexedfv(index, v);
+    d_4_1_Core->f.ViewportIndexedfv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
 {
-    d_4_1_Core->ViewportIndexedf(index, x, y, w, h);
+    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
 {
-    d_4_1_Core->ViewportArrayv(first, count, v);
+    d_4_1_Core->f.ViewportArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_4_1_Core->GetVertexAttribLdv(index, pname, params);
+    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_4_1_Core->VertexAttribLPointer(index, size, type, stride, pointer);
+    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribL4dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL4dv(index, v);
+    d_4_1_Core->f.VertexAttribL4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribL3dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL3dv(index, v);
+    d_4_1_Core->f.VertexAttribL3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribL2dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL2dv(index, v);
+    d_4_1_Core->f.VertexAttribL2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribL1dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL1dv(index, v);
+    d_4_1_Core->f.VertexAttribL1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_1_Core->VertexAttribL4d(index, x, y, z, w);
+    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_1_Core->VertexAttribL3d(index, x, y, z);
+    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_4_1_Core->VertexAttribL2d(index, x, y);
+    d_4_1_Core->f.VertexAttribL2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribL1d(GLuint index, GLdouble x)
 {
-    d_4_1_Core->VertexAttribL1d(index, x);
+    d_4_1_Core->f.VertexAttribL1d(index, x);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_4_1_Core->GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glValidateProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->ValidateProgramPipeline(pipeline);
+    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform4uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_4_1_Core->ProgramUniform4ui(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform4dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
 {
-    d_4_1_Core->ProgramUniform4d(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform4fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_4_1_Core->ProgramUniform4f(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform4iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_4_1_Core->ProgramUniform4i(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform3uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_4_1_Core->ProgramUniform3ui(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform3dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
 {
-    d_4_1_Core->ProgramUniform3d(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform3fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_4_1_Core->ProgramUniform3f(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform3iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_4_1_Core->ProgramUniform3i(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform2uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
 {
-    d_4_1_Core->ProgramUniform2ui(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform2dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
 {
-    d_4_1_Core->ProgramUniform2d(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform2fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
 {
-    d_4_1_Core->ProgramUniform2f(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform2iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
 {
-    d_4_1_Core->ProgramUniform2i(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform1uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
 {
-    d_4_1_Core->ProgramUniform1ui(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform1dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
 {
-    d_4_1_Core->ProgramUniform1d(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform1fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
 {
-    d_4_1_Core->ProgramUniform1f(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform1iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramUniform1i(GLuint program, GLint location, GLint v0)
 {
-    d_4_1_Core->ProgramUniform1i(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
 {
-    d_4_1_Core->GetProgramPipelineiv(pipeline, pname, params);
+    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsProgramPipeline(GLuint pipeline)
 {
-    return d_4_1_Core->IsProgramPipeline(pipeline);
+    return d_4_1_Core->f.IsProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
 {
-    d_4_1_Core->GenProgramPipelines(n, pipelines);
+    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
 {
-    d_4_1_Core->DeleteProgramPipelines(n, pipelines);
+    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBindProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->BindProgramPipeline(pipeline);
+    d_4_1_Core->f.BindProgramPipeline(pipeline);
 }
 
 inline GLuint QOpenGLFunctions_4_1_Compatibility::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings)
 {
-    return d_4_1_Core->CreateShaderProgramv(type, count, strings);
+    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glActiveShaderProgram(GLuint pipeline, GLuint program)
 {
-    d_4_1_Core->ActiveShaderProgram(pipeline, program);
+    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
 {
-    d_4_1_Core->UseProgramStages(pipeline, stages, program);
+    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramParameteri(GLuint program, GLenum pname, GLint value)
 {
-    d_4_1_Core->ProgramParameteri(program, pname, value);
+    d_4_1_Core->f.ProgramParameteri(program, pname, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length)
 {
-    d_4_1_Core->ProgramBinary(program, binaryFormat, binary, length);
+    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
 {
-    d_4_1_Core->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
+    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glClearDepthf(GLfloat dd)
 {
-    d_4_1_Core->ClearDepthf(dd);
+    d_4_1_Core->f.ClearDepthf(dd);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDepthRangef(GLfloat n, GLfloat f)
 {
-    d_4_1_Core->DepthRangef(n, f);
+    d_4_1_Core->f.DepthRangef(n, f);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
 {
-    d_4_1_Core->GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length)
 {
-    d_4_1_Core->ShaderBinary(count, shaders, binaryformat, binary, length);
+    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glReleaseShaderCompiler()
 {
-    d_4_1_Core->ReleaseShaderCompiler();
+    d_4_1_Core->f.ReleaseShaderCompiler();
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_4_1_Compatibility::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_4_1_Compatibility::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_4_1_Compatibility::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
 // OpenGL 1.1 deprecated functions
 inline void QOpenGLFunctions_4_1_Compatibility::glPushClientAttrib(GLbitfield mask)
 {
-    d_1_1_Deprecated->PushClientAttrib(mask);
+    d_1_1_Deprecated->f.PushClientAttrib(mask);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPopClientAttrib()
 {
-    d_1_1_Deprecated->PopClientAttrib();
+    d_1_1_Deprecated->f.PopClientAttrib();
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 {
-    d_1_1_Deprecated->PrioritizeTextures(n, textures, priorities);
+    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Compatibility::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-    return d_1_1_Deprecated->AreTexturesResident(n, textures, residences);
+    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->VertexPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->TexCoordPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->NormalPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->InterleavedArrays(format, stride, pointer);
+    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->IndexPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEnableClientState(GLenum array)
 {
-    d_1_1_Deprecated->EnableClientState(array);
+    d_1_1_Deprecated->f.EnableClientState(array);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->EdgeFlagPointer(stride, pointer);
+    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glDisableClientState(GLenum array)
 {
-    d_1_1_Deprecated->DisableClientState(array);
+    d_1_1_Deprecated->f.DisableClientState(array);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->ColorPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glArrayElement(GLint i)
 {
-    d_1_1_Deprecated->ArrayElement(i);
+    d_1_1_Deprecated->f.ArrayElement(i);
 }
 
 
 // OpenGL 1.2 deprecated functions
 inline void QOpenGLFunctions_4_1_Compatibility::glResetMinmax(GLenum target)
 {
-    d_1_2_Deprecated->ResetMinmax(target);
+    d_1_2_Deprecated->f.ResetMinmax(target);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glResetHistogram(GLenum target)
 {
-    d_1_2_Deprecated->ResetHistogram(target);
+    d_1_2_Deprecated->f.ResetHistogram(target);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Minmax(target, internalformat, sink);
+    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Histogram(target, width, internalformat, sink);
+    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetMinmax(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetHistogramParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetHistogramParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetHistogram(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
 {
-    d_1_2_Deprecated->SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
+    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
 {
-    d_1_2_Deprecated->GetSeparableFilter(target, format, type, row, column, span);
+    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
 {
-    d_1_2_Deprecated->GetConvolutionFilter(target, format, type, image);
+    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
+    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter1D(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
 {
-    d_1_2_Deprecated->ConvolutionParameteri(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
 {
-    d_1_2_Deprecated->ConvolutionParameterf(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter1D(target, internalformat, width, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorSubTable(target, start, x, y, width);
+    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
 {
-    d_1_2_Deprecated->ColorSubTable(target, start, count, format, type, data);
+    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
 {
-    d_1_2_Deprecated->GetColorTable(target, format, type, table);
+    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorTable(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
 {
-    d_1_2_Deprecated->ColorTable(target, internalformat, width, format, type, table);
+    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
 }
 
 
 // OpenGL 1.3 deprecated functions
 inline void QOpenGLFunctions_4_1_Compatibility::glMultTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixd(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixf(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLoadTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixd(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glLoadTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixf(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord4sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_3_Deprecated->MultiTexCoord4s(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord4iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_3_Deprecated->MultiTexCoord4i(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_3_Deprecated->MultiTexCoord4f(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_3_Deprecated->MultiTexCoord4d(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord3sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
 {
-    d_1_3_Deprecated->MultiTexCoord3s(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord3iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
 {
-    d_1_3_Deprecated->MultiTexCoord3i(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_3_Deprecated->MultiTexCoord3f(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_3_Deprecated->MultiTexCoord3d(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord2sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
 {
-    d_1_3_Deprecated->MultiTexCoord2s(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord2iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
 {
-    d_1_3_Deprecated->MultiTexCoord2i(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
 {
-    d_1_3_Deprecated->MultiTexCoord2f(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
 {
-    d_1_3_Deprecated->MultiTexCoord2d(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord1sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord1s(GLenum target, GLshort s)
 {
-    d_1_3_Deprecated->MultiTexCoord1s(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord1iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord1i(GLenum target, GLint s)
 {
-    d_1_3_Deprecated->MultiTexCoord1i(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord1f(GLenum target, GLfloat s)
 {
-    d_1_3_Deprecated->MultiTexCoord1f(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glMultiTexCoord1d(GLenum target, GLdouble s)
 {
-    d_1_3_Deprecated->MultiTexCoord1d(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glClientActiveTexture(GLenum texture)
 {
-    d_1_3_Deprecated->ClientActiveTexture(texture);
+    d_1_3_Deprecated->f.ClientActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 deprecated functions
 inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos3sv(v);
+    d_1_4_Deprecated->f.WindowPos3sv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_4_Deprecated->WindowPos3s(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos3iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos3iv(v);
+    d_1_4_Deprecated->f.WindowPos3iv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_4_Deprecated->WindowPos3i(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos3fv(v);
+    d_1_4_Deprecated->f.WindowPos3fv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_4_Deprecated->WindowPos3f(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos3dv(v);
+    d_1_4_Deprecated->f.WindowPos3dv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_4_Deprecated->WindowPos3d(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos2sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos2sv(v);
+    d_1_4_Deprecated->f.WindowPos2sv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos2s(GLshort x, GLshort y)
 {
-    d_1_4_Deprecated->WindowPos2s(x, y);
+    d_1_4_Deprecated->f.WindowPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos2iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos2iv(v);
+    d_1_4_Deprecated->f.WindowPos2iv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos2i(GLint x, GLint y)
 {
-    d_1_4_Deprecated->WindowPos2i(x, y);
+    d_1_4_Deprecated->f.WindowPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos2fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos2fv(v);
+    d_1_4_Deprecated->f.WindowPos2fv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos2f(GLfloat x, GLfloat y)
 {
-    d_1_4_Deprecated->WindowPos2f(x, y);
+    d_1_4_Deprecated->f.WindowPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos2dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos2dv(v);
+    d_1_4_Deprecated->f.WindowPos2dv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glWindowPos2d(GLdouble x, GLdouble y)
 {
-    d_1_4_Deprecated->WindowPos2d(x, y);
+    d_1_4_Deprecated->f.WindowPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->SecondaryColorPointer(size, type, stride, pointer);
+    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3usv(const GLushort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3usv(v);
+    d_1_4_Deprecated->f.SecondaryColor3usv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3us(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3uiv(const GLuint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3uiv(v);
+    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ui(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3ubv(const GLubyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3ubv(v);
+    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ub(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3sv(v);
+    d_1_4_Deprecated->f.SecondaryColor3sv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3s(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3iv(const GLint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3iv(v);
+    d_1_4_Deprecated->f.SecondaryColor3iv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3i(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->SecondaryColor3fv(v);
+    d_1_4_Deprecated->f.SecondaryColor3fv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_4_Deprecated->SecondaryColor3f(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->SecondaryColor3dv(v);
+    d_1_4_Deprecated->f.SecondaryColor3dv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_4_Deprecated->SecondaryColor3d(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3bv(const GLbyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3bv(v);
+    d_1_4_Deprecated->f.SecondaryColor3bv(v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3b(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->FogCoordPointer(type, stride, pointer);
+    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFogCoorddv(const GLdouble *coord)
 {
-    d_1_4_Deprecated->FogCoorddv(coord);
+    d_1_4_Deprecated->f.FogCoorddv(coord);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFogCoordd(GLdouble coord)
 {
-    d_1_4_Deprecated->FogCoordd(coord);
+    d_1_4_Deprecated->f.FogCoordd(coord);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFogCoordfv(const GLfloat *coord)
 {
-    d_1_4_Deprecated->FogCoordfv(coord);
+    d_1_4_Deprecated->f.FogCoordfv(coord);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glFogCoordf(GLfloat coord)
 {
-    d_1_4_Deprecated->FogCoordf(coord);
+    d_1_4_Deprecated->f.FogCoordf(coord);
 }
 
 
@@ -5254,182 +5255,182 @@ inline void QOpenGLFunctions_4_1_Compatibility::glFogCoordf(GLfloat coord)
 // OpenGL 2.0 deprecated functions
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4usv(index, v);
+    d_2_0_Core->f.VertexAttrib4usv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4uiv(index, v);
+    d_2_0_Core->f.VertexAttrib4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4ubv(index, v);
+    d_2_0_Core->f.VertexAttrib4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4sv(index, v);
+    d_2_0_Core->f.VertexAttrib4sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4iv(index, v);
+    d_2_0_Core->f.VertexAttrib4iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib4fv(index, v);
+    d_2_0_Core->f.VertexAttrib4fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib4dv(index, v);
+    d_2_0_Core->f.VertexAttrib4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4bv(index, v);
+    d_2_0_Core->f.VertexAttrib4bv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4Nusv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4Nuiv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nubv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
 {
-    d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4Nsv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4Niv(index, v);
+    d_2_0_Core->f.VertexAttrib4Niv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nbv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib3sv(index, v);
+    d_2_0_Core->f.VertexAttrib3sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
 {
-    d_2_0_Core->VertexAttrib3s(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib3fv(index, v);
+    d_2_0_Core->f.VertexAttrib3fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_2_0_Core->VertexAttrib3f(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib3dv(index, v);
+    d_2_0_Core->f.VertexAttrib3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_2_0_Core->VertexAttrib3d(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib2sv(index, v);
+    d_2_0_Core->f.VertexAttrib2sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
 {
-    d_2_0_Core->VertexAttrib2s(index, x, y);
+    d_2_0_Core->f.VertexAttrib2s(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib2fv(index, v);
+    d_2_0_Core->f.VertexAttrib2fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
 {
-    d_2_0_Core->VertexAttrib2f(index, x, y);
+    d_2_0_Core->f.VertexAttrib2f(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib2dv(index, v);
+    d_2_0_Core->f.VertexAttrib2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_2_0_Core->VertexAttrib2d(index, x, y);
+    d_2_0_Core->f.VertexAttrib2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib1sv(index, v);
+    d_2_0_Core->f.VertexAttrib1sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
 {
-    d_2_0_Core->VertexAttrib1s(index, x);
+    d_2_0_Core->f.VertexAttrib1s(index, x);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib1fv(index, v);
+    d_2_0_Core->f.VertexAttrib1fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
 {
-    d_2_0_Core->VertexAttrib1f(index, x);
+    d_2_0_Core->f.VertexAttrib1f(index, x);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib1dv(index, v);
+    d_2_0_Core->f.VertexAttrib1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
 {
-    d_2_0_Core->VertexAttrib1d(index, x);
+    d_2_0_Core->f.VertexAttrib1d(index, x);
 }
 
 
@@ -5438,102 +5439,102 @@ inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttrib1d(GLuint index, G
 // OpenGL 3.0 deprecated functions
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
 {
-    d_3_0_Core->VertexAttribI4usv(index, v);
+    d_3_0_Core->f.VertexAttribI4usv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
 {
-    d_3_0_Core->VertexAttribI4ubv(index, v);
+    d_3_0_Core->f.VertexAttribI4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
 {
-    d_3_0_Core->VertexAttribI4sv(index, v);
+    d_3_0_Core->f.VertexAttribI4sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
 {
-    d_3_0_Core->VertexAttribI4bv(index, v);
+    d_3_0_Core->f.VertexAttribI4bv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI4uiv(index, v);
+    d_3_0_Core->f.VertexAttribI4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI3uiv(index, v);
+    d_3_0_Core->f.VertexAttribI3uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI2uiv(index, v);
+    d_3_0_Core->f.VertexAttribI2uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI1uiv(index, v);
+    d_3_0_Core->f.VertexAttribI1uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI4iv(index, v);
+    d_3_0_Core->f.VertexAttribI4iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI3iv(index, v);
+    d_3_0_Core->f.VertexAttribI3iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI2iv(index, v);
+    d_3_0_Core->f.VertexAttribI2iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI1iv(index, v);
+    d_3_0_Core->f.VertexAttribI1iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
 {
-    d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
 {
-    d_3_0_Core->VertexAttribI3ui(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
 {
-    d_3_0_Core->VertexAttribI2ui(index, x, y);
+    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
 {
-    d_3_0_Core->VertexAttribI1ui(index, x);
+    d_3_0_Core->f.VertexAttribI1ui(index, x);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
 {
-    d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
 {
-    d_3_0_Core->VertexAttribI3i(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
 {
-    d_3_0_Core->VertexAttribI2i(index, x, y);
+    d_3_0_Core->f.VertexAttribI2i(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
 {
-    d_3_0_Core->VertexAttribI1i(index, x);
+    d_3_0_Core->f.VertexAttribI1i(index, x);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_4_1_core.cpp b/src/gui/opengl/qopenglfunctions_4_1_core.cpp
index b3c2c11d60d..ff3d191781d 100644
--- a/src/gui/opengl/qopenglfunctions_4_1_core.cpp
+++ b/src/gui/opengl/qopenglfunctions_4_1_core.cpp
@@ -86,62 +86,48 @@ QOpenGLFunctions_4_1_Core::QOpenGLFunctions_4_1_Core()
 
 QOpenGLFunctions_4_1_Core::~QOpenGLFunctions_4_1_Core()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
-    if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        delete d_3_2_Core;
-    }
-    if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        delete d_3_3_Core;
-    }
-    if (d_4_0_Core && !d_4_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_0_Core->context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        delete d_4_0_Core;
-    }
-    if (d_4_1_Core && !d_4_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_1_Core->context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        delete d_4_1_Core;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
+    if (d_3_2_Core)
+        d_3_2_Core->refs.deref();
+    Q_ASSERT(d_3_2_Core->refs.load());
+    if (d_3_3_Core)
+        d_3_3_Core->refs.deref();
+    Q_ASSERT(d_3_3_Core->refs.load());
+    if (d_4_0_Core)
+        d_4_0_Core->refs.deref();
+    Q_ASSERT(d_4_0_Core->refs.load());
+    if (d_4_1_Core)
+        d_4_1_Core->refs.deref();
+    Q_ASSERT(d_4_1_Core->refs.load());
 }
 
 bool QOpenGLFunctions_4_1_Core::initializeOpenGLFunctions()
@@ -160,114 +146,58 @@ bool QOpenGLFunctions_4_1_Core::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
-        }
         d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
-        }
         d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus(), d);
-        }
         d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus(), d);
-        }
         d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_4_1_core.h b/src/gui/opengl/qopenglfunctions_4_1_core.h
index 919b44c20b3..17d922e2610 100644
--- a/src/gui/opengl/qopenglfunctions_4_1_core.h
+++ b/src/gui/opengl/qopenglfunctions_4_1_core.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -574,242 +575,242 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_4_1_Core::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Core::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_1_Core::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_4_1_Core::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_4_1_Core::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_4_1_Core::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
@@ -828,57 +829,57 @@ inline void QOpenGLFunctions_4_1_Core::glIndexub(GLubyte c)
 
 inline GLboolean QOpenGLFunctions_4_1_Core::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetPointerv(GLenum pname, GLvoid* *params)
@@ -890,1067 +891,1067 @@ inline void QOpenGLFunctions_4_1_Core::glGetPointerv(GLenum pname, GLvoid* *para
 
 inline void QOpenGLFunctions_4_1_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_4_1_Core::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_4_1_Core::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_4_1_Core::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_4_1_Core::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Core::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_4_1_Core::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Core::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Core::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Core::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Core::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_4_1_Core::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_4_1_Core::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, obj);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_4_1_Core::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_4_1_Core::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_4_1_Core::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_4_1_Core::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline GLvoid* QOpenGLFunctions_4_1_Core::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_4_1_Core::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Core::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Core::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_1_Core::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_4_1_Core::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Core::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_4_1_Core::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_4_1_Core::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
 // OpenGL 3.2 core functions
 inline void QOpenGLFunctions_4_1_Core::glSampleMaski(GLuint index, GLbitfield mask)
 {
-    d_3_2_Core->SampleMaski(index, mask);
+    d_3_2_Core->f.SampleMaski(index, mask);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
 {
-    d_3_2_Core->GetMultisamplefv(pname, index, val);
+    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
-    d_3_2_Core->GetSynciv(sync, pname, bufSize, length, values);
+    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetInteger64v(GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetInteger64v(pname, params);
+    d_3_2_Core->f.GetInteger64v(pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    d_3_2_Core->WaitSync(sync, flags, timeout);
+    d_3_2_Core->f.WaitSync(sync, flags, timeout);
 }
 
 inline GLenum QOpenGLFunctions_4_1_Core::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    return d_3_2_Core->ClientWaitSync(sync, flags, timeout);
+    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDeleteSync(GLsync sync)
 {
-    d_3_2_Core->DeleteSync(sync);
+    d_3_2_Core->f.DeleteSync(sync);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Core::glIsSync(GLsync sync)
 {
-    return d_3_2_Core->IsSync(sync);
+    return d_3_2_Core->f.IsSync(sync);
 }
 
 inline GLsync QOpenGLFunctions_4_1_Core::glFenceSync(GLenum condition, GLbitfield flags)
 {
-    return d_3_2_Core->FenceSync(condition, flags);
+    return d_3_2_Core->f.FenceSync(condition, flags);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProvokingVertex(GLenum mode)
 {
-    d_3_2_Core->ProvokingVertex(mode);
+    d_3_2_Core->f.ProvokingVertex(mode);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
 {
-    d_3_2_Core->MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
-    d_3_2_Core->FramebufferTexture(target, attachment, texture, level);
+    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetBufferParameteri64v(target, pname, params);
+    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64i_v(target, index, data);
+    d_3_2_Core->f.GetInteger64i_v(target, index, data);
 }
 
 
 // OpenGL 3.3 core functions
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP4uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP4ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP3uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP3ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP2uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP2ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP1uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP1ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
@@ -2173,776 +2174,776 @@ inline void QOpenGLFunctions_4_1_Core::glVertexP2ui(GLenum type, GLuint value)
 
 inline void QOpenGLFunctions_4_1_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
 {
-    d_3_3_Core->GetQueryObjectui64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
 {
-    d_3_3_Core->GetQueryObjecti64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glQueryCounter(GLuint id, GLenum target)
 {
-    d_3_3_Core->QueryCounter(id, target);
+    d_3_3_Core->f.QueryCounter(id, target);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
 {
-    d_3_3_Core->GetSamplerParameterIuiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
 {
-    d_3_3_Core->GetSamplerParameterfv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameterIiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameteriv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
 {
-    d_3_3_Core->SamplerParameterIuiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameterIiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
 {
-    d_3_3_Core->SamplerParameterfv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
 {
-    d_3_3_Core->SamplerParameterf(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameteriv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
-    d_3_3_Core->SamplerParameteri(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBindSampler(GLuint unit, GLuint sampler)
 {
-    d_3_3_Core->BindSampler(unit, sampler);
+    d_3_3_Core->f.BindSampler(unit, sampler);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Core::glIsSampler(GLuint sampler)
 {
-    return d_3_3_Core->IsSampler(sampler);
+    return d_3_3_Core->f.IsSampler(sampler);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDeleteSamplers(GLsizei count, const GLuint *samplers)
 {
-    d_3_3_Core->DeleteSamplers(count, samplers);
+    d_3_3_Core->f.DeleteSamplers(count, samplers);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGenSamplers(GLsizei count, GLuint *samplers)
 {
-    d_3_3_Core->GenSamplers(count, samplers);
+    d_3_3_Core->f.GenSamplers(count, samplers);
 }
 
 inline GLint QOpenGLFunctions_4_1_Core::glGetFragDataIndex(GLuint program, const GLchar *name)
 {
-    return d_3_3_Core->GetFragDataIndex(program, name);
+    return d_3_3_Core->f.GetFragDataIndex(program, name);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
 {
-    d_3_3_Core->BindFragDataLocationIndexed(program, colorNumber, index, name);
+    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribDivisor(GLuint index, GLuint divisor)
 {
-    d_3_3_Core->VertexAttribDivisor(index, divisor);
+    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
 }
 
 
 // OpenGL 4.0 core functions
 inline void QOpenGLFunctions_4_1_Core::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
 {
-    d_4_0_Core->GetQueryIndexediv(target, index, pname, params);
+    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glEndQueryIndexed(GLenum target, GLuint index)
 {
-    d_4_0_Core->EndQueryIndexed(target, index);
+    d_4_0_Core->f.EndQueryIndexed(target, index);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
 {
-    d_4_0_Core->BeginQueryIndexed(target, index, id);
+    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
 {
-    d_4_0_Core->DrawTransformFeedbackStream(mode, id, stream);
+    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDrawTransformFeedback(GLenum mode, GLuint id)
 {
-    d_4_0_Core->DrawTransformFeedback(mode, id);
+    d_4_0_Core->f.DrawTransformFeedback(mode, id);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glResumeTransformFeedback()
 {
-    d_4_0_Core->ResumeTransformFeedback();
+    d_4_0_Core->f.ResumeTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_1_Core::glPauseTransformFeedback()
 {
-    d_4_0_Core->PauseTransformFeedback();
+    d_4_0_Core->f.PauseTransformFeedback();
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Core::glIsTransformFeedback(GLuint id)
 {
-    return d_4_0_Core->IsTransformFeedback(id);
+    return d_4_0_Core->f.IsTransformFeedback(id);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
 {
-    d_4_0_Core->GenTransformFeedbacks(n, ids);
+    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
 {
-    d_4_0_Core->DeleteTransformFeedbacks(n, ids);
+    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBindTransformFeedback(GLenum target, GLuint id)
 {
-    d_4_0_Core->BindTransformFeedback(target, id);
+    d_4_0_Core->f.BindTransformFeedback(target, id);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glPatchParameterfv(GLenum pname, const GLfloat *values)
 {
-    d_4_0_Core->PatchParameterfv(pname, values);
+    d_4_0_Core->f.PatchParameterfv(pname, values);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glPatchParameteri(GLenum pname, GLint value)
 {
-    d_4_0_Core->PatchParameteri(pname, value);
+    d_4_0_Core->f.PatchParameteri(pname, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetProgramStageiv(program, shadertype, pname, values);
+    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
 {
-    d_4_0_Core->GetUniformSubroutineuiv(shadertype, location, params);
+    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
 {
-    d_4_0_Core->UniformSubroutinesuiv(shadertype, count, indices);
+    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
+    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
 }
 
 inline GLuint QOpenGLFunctions_4_1_Core::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineIndex(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
 }
 
 inline GLint QOpenGLFunctions_4_1_Core::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineUniformLocation(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
 {
-    d_4_0_Core->GetUniformdv(program, location, params);
+    d_4_0_Core->f.GetUniformdv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform4dv(location, count, value);
+    d_4_0_Core->f.Uniform4dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform3dv(location, count, value);
+    d_4_0_Core->f.Uniform3dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform2dv(location, count, value);
+    d_4_0_Core->f.Uniform2dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform1dv(location, count, value);
+    d_4_0_Core->f.Uniform1dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_0_Core->Uniform4d(location, x, y, z, w);
+    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_0_Core->Uniform3d(location, x, y, z);
+    d_4_0_Core->f.Uniform3d(location, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform2d(GLint location, GLdouble x, GLdouble y)
 {
-    d_4_0_Core->Uniform2d(location, x, y);
+    d_4_0_Core->f.Uniform2d(location, x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUniform1d(GLint location, GLdouble x)
 {
-    d_4_0_Core->Uniform1d(location, x);
+    d_4_0_Core->f.Uniform1d(location, x);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
 {
-    d_4_0_Core->DrawElementsIndirect(mode, type, indirect);
+    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDrawArraysIndirect(GLenum mode, const GLvoid *indirect)
 {
-    d_4_0_Core->DrawArraysIndirect(mode, indirect);
+    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-    d_4_0_Core->BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
 {
-    d_4_0_Core->BlendFunci(buf, src, dst);
+    d_4_0_Core->f.BlendFunci(buf, src, dst);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
 {
-    d_4_0_Core->BlendEquationSeparatei(buf, modeRGB, modeAlpha);
+    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBlendEquationi(GLuint buf, GLenum mode)
 {
-    d_4_0_Core->BlendEquationi(buf, mode);
+    d_4_0_Core->f.BlendEquationi(buf, mode);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glMinSampleShading(GLfloat value)
 {
-    d_4_0_Core->MinSampleShading(value);
+    d_4_0_Core->f.MinSampleShading(value);
 }
 
 
 // OpenGL 4.1 core functions
 inline void QOpenGLFunctions_4_1_Core::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
 {
-    d_4_1_Core->GetDoublei_v(target, index, data);
+    d_4_1_Core->f.GetDoublei_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
 {
-    d_4_1_Core->GetFloati_v(target, index, data);
+    d_4_1_Core->f.GetFloati_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
 {
-    d_4_1_Core->DepthRangeIndexed(index, n, f);
+    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
 {
-    d_4_1_Core->DepthRangeArrayv(first, count, v);
+    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glScissorIndexedv(GLuint index, const GLint *v)
 {
-    d_4_1_Core->ScissorIndexedv(index, v);
+    d_4_1_Core->f.ScissorIndexedv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
 {
-    d_4_1_Core->ScissorIndexed(index, left, bottom, width, height);
+    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
 {
-    d_4_1_Core->ScissorArrayv(first, count, v);
+    d_4_1_Core->f.ScissorArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glViewportIndexedfv(GLuint index, const GLfloat *v)
 {
-    d_4_1_Core->ViewportIndexedfv(index, v);
+    d_4_1_Core->f.ViewportIndexedfv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
 {
-    d_4_1_Core->ViewportIndexedf(index, x, y, w, h);
+    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
 {
-    d_4_1_Core->ViewportArrayv(first, count, v);
+    d_4_1_Core->f.ViewportArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_4_1_Core->GetVertexAttribLdv(index, pname, params);
+    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_4_1_Core->VertexAttribLPointer(index, size, type, stride, pointer);
+    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribL4dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL4dv(index, v);
+    d_4_1_Core->f.VertexAttribL4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribL3dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL3dv(index, v);
+    d_4_1_Core->f.VertexAttribL3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribL2dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL2dv(index, v);
+    d_4_1_Core->f.VertexAttribL2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribL1dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL1dv(index, v);
+    d_4_1_Core->f.VertexAttribL1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_1_Core->VertexAttribL4d(index, x, y, z, w);
+    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_1_Core->VertexAttribL3d(index, x, y, z);
+    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_4_1_Core->VertexAttribL2d(index, x, y);
+    d_4_1_Core->f.VertexAttribL2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glVertexAttribL1d(GLuint index, GLdouble x)
 {
-    d_4_1_Core->VertexAttribL1d(index, x);
+    d_4_1_Core->f.VertexAttribL1d(index, x);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_4_1_Core->GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glValidateProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->ValidateProgramPipeline(pipeline);
+    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform4uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_4_1_Core->ProgramUniform4ui(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform4dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
 {
-    d_4_1_Core->ProgramUniform4d(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform4fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_4_1_Core->ProgramUniform4f(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform4iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_4_1_Core->ProgramUniform4i(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform3uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_4_1_Core->ProgramUniform3ui(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform3dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
 {
-    d_4_1_Core->ProgramUniform3d(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform3fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_4_1_Core->ProgramUniform3f(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform3iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_4_1_Core->ProgramUniform3i(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform2uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
 {
-    d_4_1_Core->ProgramUniform2ui(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform2dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
 {
-    d_4_1_Core->ProgramUniform2d(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform2fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
 {
-    d_4_1_Core->ProgramUniform2f(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform2iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
 {
-    d_4_1_Core->ProgramUniform2i(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform1uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
 {
-    d_4_1_Core->ProgramUniform1ui(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform1dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
 {
-    d_4_1_Core->ProgramUniform1d(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform1fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
 {
-    d_4_1_Core->ProgramUniform1f(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform1iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramUniform1i(GLuint program, GLint location, GLint v0)
 {
-    d_4_1_Core->ProgramUniform1i(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
 {
-    d_4_1_Core->GetProgramPipelineiv(pipeline, pname, params);
+    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_1_Core::glIsProgramPipeline(GLuint pipeline)
 {
-    return d_4_1_Core->IsProgramPipeline(pipeline);
+    return d_4_1_Core->f.IsProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
 {
-    d_4_1_Core->GenProgramPipelines(n, pipelines);
+    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
 {
-    d_4_1_Core->DeleteProgramPipelines(n, pipelines);
+    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glBindProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->BindProgramPipeline(pipeline);
+    d_4_1_Core->f.BindProgramPipeline(pipeline);
 }
 
 inline GLuint QOpenGLFunctions_4_1_Core::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings)
 {
-    return d_4_1_Core->CreateShaderProgramv(type, count, strings);
+    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glActiveShaderProgram(GLuint pipeline, GLuint program)
 {
-    d_4_1_Core->ActiveShaderProgram(pipeline, program);
+    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
 {
-    d_4_1_Core->UseProgramStages(pipeline, stages, program);
+    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramParameteri(GLuint program, GLenum pname, GLint value)
 {
-    d_4_1_Core->ProgramParameteri(program, pname, value);
+    d_4_1_Core->f.ProgramParameteri(program, pname, value);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length)
 {
-    d_4_1_Core->ProgramBinary(program, binaryFormat, binary, length);
+    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
 {
-    d_4_1_Core->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
+    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glClearDepthf(GLfloat dd)
 {
-    d_4_1_Core->ClearDepthf(dd);
+    d_4_1_Core->f.ClearDepthf(dd);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glDepthRangef(GLfloat n, GLfloat f)
 {
-    d_4_1_Core->DepthRangef(n, f);
+    d_4_1_Core->f.DepthRangef(n, f);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
 {
-    d_4_1_Core->GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length)
 {
-    d_4_1_Core->ShaderBinary(count, shaders, binaryformat, binary, length);
+    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_1_Core::glReleaseShaderCompiler()
 {
-    d_4_1_Core->ReleaseShaderCompiler();
+    d_4_1_Core->f.ReleaseShaderCompiler();
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_4_2_compatibility.cpp b/src/gui/opengl/qopenglfunctions_4_2_compatibility.cpp
index 2f6dbc9b78e..58527e92b52 100644
--- a/src/gui/opengl/qopenglfunctions_4_2_compatibility.cpp
+++ b/src/gui/opengl/qopenglfunctions_4_2_compatibility.cpp
@@ -94,90 +94,69 @@ QOpenGLFunctions_4_2_Compatibility::QOpenGLFunctions_4_2_Compatibility()
 
 QOpenGLFunctions_4_2_Compatibility::~QOpenGLFunctions_4_2_Compatibility()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
-    if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        delete d_3_2_Core;
-    }
-    if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        delete d_3_3_Core;
-    }
-    if (d_4_0_Core && !d_4_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_0_Core->context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        delete d_4_0_Core;
-    }
-    if (d_4_1_Core && !d_4_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_1_Core->context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        delete d_4_1_Core;
-    }
-    if (d_4_2_Core && !d_4_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_2_Core->context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        delete d_4_2_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
-    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        delete d_1_1_Deprecated;
-    }
-    if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        delete d_1_2_Deprecated;
-    }
-    if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        delete d_1_3_Deprecated;
-    }
-    if (d_1_4_Deprecated && !d_1_4_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        delete d_1_4_Deprecated;
-    }
-    if (d_3_3_Deprecated && !d_3_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Deprecated->context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        delete d_3_3_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
+    if (d_3_2_Core)
+        d_3_2_Core->refs.deref();
+    Q_ASSERT(d_3_2_Core->refs.load());
+    if (d_3_3_Core)
+        d_3_3_Core->refs.deref();
+    Q_ASSERT(d_3_3_Core->refs.load());
+    if (d_4_0_Core)
+        d_4_0_Core->refs.deref();
+    Q_ASSERT(d_4_0_Core->refs.load());
+    if (d_4_1_Core)
+        d_4_1_Core->refs.deref();
+    Q_ASSERT(d_4_1_Core->refs.load());
+    if (d_4_2_Core)
+        d_4_2_Core->refs.deref();
+    Q_ASSERT(d_4_2_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
+    if (d_1_1_Deprecated)
+        d_1_1_Deprecated->refs.deref();
+    Q_ASSERT(d_1_1_Deprecated->refs.load());
+    if (d_1_2_Deprecated)
+        d_1_2_Deprecated->refs.deref();
+    Q_ASSERT(d_1_2_Deprecated->refs.load());
+    if (d_1_3_Deprecated)
+        d_1_3_Deprecated->refs.deref();
+    Q_ASSERT(d_1_3_Deprecated->refs.load());
+    if (d_1_4_Deprecated)
+        d_1_4_Deprecated->refs.deref();
+    Q_ASSERT(d_1_4_Deprecated->refs.load());
+    if (d_3_3_Deprecated)
+        d_3_3_Deprecated->refs.deref();
+    Q_ASSERT(d_3_3_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_4_2_Compatibility::initializeOpenGLFunctions()
@@ -196,170 +175,86 @@ bool QOpenGLFunctions_4_2_Compatibility::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
-        }
         d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
-        }
         d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus(), d);
-        }
         d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus(), d);
-        }
         d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus(), d);
-        }
         d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_4_2_compatibility.h b/src/gui/opengl/qopenglfunctions_4_2_compatibility.h
index b357d9fb220..cb95c399360 100644
--- a/src/gui/opengl/qopenglfunctions_4_2_compatibility.h
+++ b/src/gui/opengl/qopenglfunctions_4_2_compatibility.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -1061,4270 +1062,4270 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_4_2_Compatibility::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_2_Compatibility::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_4_2_Compatibility::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline void QOpenGLFunctions_4_2_Compatibility::glIndexubv(const GLubyte *c)
 {
-    d_1_1_Deprecated->Indexubv(c);
+    d_1_1_Deprecated->f.Indexubv(c);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glIndexub(GLubyte c)
 {
-    d_1_1_Deprecated->Indexub(c);
+    d_1_1_Deprecated->f.Indexub(c);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
 {
-    d_1_1_Deprecated->GetPointerv(pname, params);
+    d_1_1_Deprecated->f.GetPointerv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_4_2_Compatibility::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_4_2_Compatibility::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_4_2_Compatibility::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_4_2_Compatibility::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_4_2_Compatibility::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_4_2_Compatibility::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_4_2_Compatibility::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, obj);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_4_2_Compatibility::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_4_2_Compatibility::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline GLvoid* QOpenGLFunctions_4_2_Compatibility::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_4_2_Compatibility::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_2_Compatibility::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_4_2_Compatibility::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_4_2_Compatibility::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_4_2_Compatibility::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
 // OpenGL 3.2 core functions
 inline void QOpenGLFunctions_4_2_Compatibility::glSampleMaski(GLuint index, GLbitfield mask)
 {
-    d_3_2_Core->SampleMaski(index, mask);
+    d_3_2_Core->f.SampleMaski(index, mask);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
 {
-    d_3_2_Core->GetMultisamplefv(pname, index, val);
+    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
-    d_3_2_Core->GetSynciv(sync, pname, bufSize, length, values);
+    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetInteger64v(GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetInteger64v(pname, params);
+    d_3_2_Core->f.GetInteger64v(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    d_3_2_Core->WaitSync(sync, flags, timeout);
+    d_3_2_Core->f.WaitSync(sync, flags, timeout);
 }
 
 inline GLenum QOpenGLFunctions_4_2_Compatibility::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    return d_3_2_Core->ClientWaitSync(sync, flags, timeout);
+    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDeleteSync(GLsync sync)
 {
-    d_3_2_Core->DeleteSync(sync);
+    d_3_2_Core->f.DeleteSync(sync);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsSync(GLsync sync)
 {
-    return d_3_2_Core->IsSync(sync);
+    return d_3_2_Core->f.IsSync(sync);
 }
 
 inline GLsync QOpenGLFunctions_4_2_Compatibility::glFenceSync(GLenum condition, GLbitfield flags)
 {
-    return d_3_2_Core->FenceSync(condition, flags);
+    return d_3_2_Core->f.FenceSync(condition, flags);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProvokingVertex(GLenum mode)
 {
-    d_3_2_Core->ProvokingVertex(mode);
+    d_3_2_Core->f.ProvokingVertex(mode);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
 {
-    d_3_2_Core->MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
-    d_3_2_Core->FramebufferTexture(target, attachment, texture, level);
+    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetBufferParameteri64v(target, pname, params);
+    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64i_v(target, index, data);
+    d_3_2_Core->f.GetInteger64i_v(target, index, data);
 }
 
 
 // OpenGL 3.3 core functions
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP4uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP4ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP3uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP3ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP2uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP2ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP1uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP1ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->SecondaryColorP3uiv(type, color);
+    d_3_3_Deprecated->f.SecondaryColorP3uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->SecondaryColorP3ui(type, color);
+    d_3_3_Deprecated->f.SecondaryColorP3ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->ColorP4uiv(type, color);
+    d_3_3_Deprecated->f.ColorP4uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColorP4ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->ColorP4ui(type, color);
+    d_3_3_Deprecated->f.ColorP4ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->ColorP3uiv(type, color);
+    d_3_3_Deprecated->f.ColorP3uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColorP3ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->ColorP3ui(type, color);
+    d_3_3_Deprecated->f.ColorP3ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->NormalP3uiv(type, coords);
+    d_3_3_Deprecated->f.NormalP3uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->NormalP3ui(type, coords);
+    d_3_3_Deprecated->f.NormalP3ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP4uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP4uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP4ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP4ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP3uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP3uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP3ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP3ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP2uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP2uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP2ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP2ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP1uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP1uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP1ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP1ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP4uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP4uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP4ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP4ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP3uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP3uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP3ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP3ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP2uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP2uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP2ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP2ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP1uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP1uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP1ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP1ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP4uiv(type, value);
+    d_3_3_Deprecated->f.VertexP4uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexP4ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP4ui(type, value);
+    d_3_3_Deprecated->f.VertexP4ui(type, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP3uiv(type, value);
+    d_3_3_Deprecated->f.VertexP3uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexP3ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP3ui(type, value);
+    d_3_3_Deprecated->f.VertexP3ui(type, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP2uiv(type, value);
+    d_3_3_Deprecated->f.VertexP2uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexP2ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP2ui(type, value);
+    d_3_3_Deprecated->f.VertexP2ui(type, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
 {
-    d_3_3_Core->GetQueryObjectui64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
 {
-    d_3_3_Core->GetQueryObjecti64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glQueryCounter(GLuint id, GLenum target)
 {
-    d_3_3_Core->QueryCounter(id, target);
+    d_3_3_Core->f.QueryCounter(id, target);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
 {
-    d_3_3_Core->GetSamplerParameterIuiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
 {
-    d_3_3_Core->GetSamplerParameterfv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameterIiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameteriv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
 {
-    d_3_3_Core->SamplerParameterIuiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameterIiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
 {
-    d_3_3_Core->SamplerParameterfv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
 {
-    d_3_3_Core->SamplerParameterf(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameteriv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
-    d_3_3_Core->SamplerParameteri(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBindSampler(GLuint unit, GLuint sampler)
 {
-    d_3_3_Core->BindSampler(unit, sampler);
+    d_3_3_Core->f.BindSampler(unit, sampler);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsSampler(GLuint sampler)
 {
-    return d_3_3_Core->IsSampler(sampler);
+    return d_3_3_Core->f.IsSampler(sampler);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDeleteSamplers(GLsizei count, const GLuint *samplers)
 {
-    d_3_3_Core->DeleteSamplers(count, samplers);
+    d_3_3_Core->f.DeleteSamplers(count, samplers);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGenSamplers(GLsizei count, GLuint *samplers)
 {
-    d_3_3_Core->GenSamplers(count, samplers);
+    d_3_3_Core->f.GenSamplers(count, samplers);
 }
 
 inline GLint QOpenGLFunctions_4_2_Compatibility::glGetFragDataIndex(GLuint program, const GLchar *name)
 {
-    return d_3_3_Core->GetFragDataIndex(program, name);
+    return d_3_3_Core->f.GetFragDataIndex(program, name);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
 {
-    d_3_3_Core->BindFragDataLocationIndexed(program, colorNumber, index, name);
+    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribDivisor(GLuint index, GLuint divisor)
 {
-    d_3_3_Core->VertexAttribDivisor(index, divisor);
+    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
 }
 
 
 // OpenGL 4.0 core functions
 inline void QOpenGLFunctions_4_2_Compatibility::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
 {
-    d_4_0_Core->GetQueryIndexediv(target, index, pname, params);
+    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEndQueryIndexed(GLenum target, GLuint index)
 {
-    d_4_0_Core->EndQueryIndexed(target, index);
+    d_4_0_Core->f.EndQueryIndexed(target, index);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
 {
-    d_4_0_Core->BeginQueryIndexed(target, index, id);
+    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
 {
-    d_4_0_Core->DrawTransformFeedbackStream(mode, id, stream);
+    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawTransformFeedback(GLenum mode, GLuint id)
 {
-    d_4_0_Core->DrawTransformFeedback(mode, id);
+    d_4_0_Core->f.DrawTransformFeedback(mode, id);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glResumeTransformFeedback()
 {
-    d_4_0_Core->ResumeTransformFeedback();
+    d_4_0_Core->f.ResumeTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPauseTransformFeedback()
 {
-    d_4_0_Core->PauseTransformFeedback();
+    d_4_0_Core->f.PauseTransformFeedback();
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsTransformFeedback(GLuint id)
 {
-    return d_4_0_Core->IsTransformFeedback(id);
+    return d_4_0_Core->f.IsTransformFeedback(id);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
 {
-    d_4_0_Core->GenTransformFeedbacks(n, ids);
+    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
 {
-    d_4_0_Core->DeleteTransformFeedbacks(n, ids);
+    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBindTransformFeedback(GLenum target, GLuint id)
 {
-    d_4_0_Core->BindTransformFeedback(target, id);
+    d_4_0_Core->f.BindTransformFeedback(target, id);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPatchParameterfv(GLenum pname, const GLfloat *values)
 {
-    d_4_0_Core->PatchParameterfv(pname, values);
+    d_4_0_Core->f.PatchParameterfv(pname, values);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPatchParameteri(GLenum pname, GLint value)
 {
-    d_4_0_Core->PatchParameteri(pname, value);
+    d_4_0_Core->f.PatchParameteri(pname, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetProgramStageiv(program, shadertype, pname, values);
+    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
 {
-    d_4_0_Core->GetUniformSubroutineuiv(shadertype, location, params);
+    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
 {
-    d_4_0_Core->UniformSubroutinesuiv(shadertype, count, indices);
+    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
+    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
 }
 
 inline GLuint QOpenGLFunctions_4_2_Compatibility::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineIndex(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
 }
 
 inline GLint QOpenGLFunctions_4_2_Compatibility::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineUniformLocation(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
 {
-    d_4_0_Core->GetUniformdv(program, location, params);
+    d_4_0_Core->f.GetUniformdv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform4dv(location, count, value);
+    d_4_0_Core->f.Uniform4dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform3dv(location, count, value);
+    d_4_0_Core->f.Uniform3dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform2dv(location, count, value);
+    d_4_0_Core->f.Uniform2dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform1dv(location, count, value);
+    d_4_0_Core->f.Uniform1dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_0_Core->Uniform4d(location, x, y, z, w);
+    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_0_Core->Uniform3d(location, x, y, z);
+    d_4_0_Core->f.Uniform3d(location, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform2d(GLint location, GLdouble x, GLdouble y)
 {
-    d_4_0_Core->Uniform2d(location, x, y);
+    d_4_0_Core->f.Uniform2d(location, x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUniform1d(GLint location, GLdouble x)
 {
-    d_4_0_Core->Uniform1d(location, x);
+    d_4_0_Core->f.Uniform1d(location, x);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
 {
-    d_4_0_Core->DrawElementsIndirect(mode, type, indirect);
+    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawArraysIndirect(GLenum mode, const GLvoid *indirect)
 {
-    d_4_0_Core->DrawArraysIndirect(mode, indirect);
+    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-    d_4_0_Core->BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
 {
-    d_4_0_Core->BlendFunci(buf, src, dst);
+    d_4_0_Core->f.BlendFunci(buf, src, dst);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
 {
-    d_4_0_Core->BlendEquationSeparatei(buf, modeRGB, modeAlpha);
+    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBlendEquationi(GLuint buf, GLenum mode)
 {
-    d_4_0_Core->BlendEquationi(buf, mode);
+    d_4_0_Core->f.BlendEquationi(buf, mode);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMinSampleShading(GLfloat value)
 {
-    d_4_0_Core->MinSampleShading(value);
+    d_4_0_Core->f.MinSampleShading(value);
 }
 
 
 // OpenGL 4.1 core functions
 inline void QOpenGLFunctions_4_2_Compatibility::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
 {
-    d_4_1_Core->GetDoublei_v(target, index, data);
+    d_4_1_Core->f.GetDoublei_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
 {
-    d_4_1_Core->GetFloati_v(target, index, data);
+    d_4_1_Core->f.GetFloati_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
 {
-    d_4_1_Core->DepthRangeIndexed(index, n, f);
+    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
 {
-    d_4_1_Core->DepthRangeArrayv(first, count, v);
+    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glScissorIndexedv(GLuint index, const GLint *v)
 {
-    d_4_1_Core->ScissorIndexedv(index, v);
+    d_4_1_Core->f.ScissorIndexedv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
 {
-    d_4_1_Core->ScissorIndexed(index, left, bottom, width, height);
+    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
 {
-    d_4_1_Core->ScissorArrayv(first, count, v);
+    d_4_1_Core->f.ScissorArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glViewportIndexedfv(GLuint index, const GLfloat *v)
 {
-    d_4_1_Core->ViewportIndexedfv(index, v);
+    d_4_1_Core->f.ViewportIndexedfv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
 {
-    d_4_1_Core->ViewportIndexedf(index, x, y, w, h);
+    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
 {
-    d_4_1_Core->ViewportArrayv(first, count, v);
+    d_4_1_Core->f.ViewportArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_4_1_Core->GetVertexAttribLdv(index, pname, params);
+    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_4_1_Core->VertexAttribLPointer(index, size, type, stride, pointer);
+    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribL4dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL4dv(index, v);
+    d_4_1_Core->f.VertexAttribL4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribL3dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL3dv(index, v);
+    d_4_1_Core->f.VertexAttribL3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribL2dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL2dv(index, v);
+    d_4_1_Core->f.VertexAttribL2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribL1dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL1dv(index, v);
+    d_4_1_Core->f.VertexAttribL1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_1_Core->VertexAttribL4d(index, x, y, z, w);
+    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_1_Core->VertexAttribL3d(index, x, y, z);
+    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_4_1_Core->VertexAttribL2d(index, x, y);
+    d_4_1_Core->f.VertexAttribL2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribL1d(GLuint index, GLdouble x)
 {
-    d_4_1_Core->VertexAttribL1d(index, x);
+    d_4_1_Core->f.VertexAttribL1d(index, x);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_4_1_Core->GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glValidateProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->ValidateProgramPipeline(pipeline);
+    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform4uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_4_1_Core->ProgramUniform4ui(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform4dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
 {
-    d_4_1_Core->ProgramUniform4d(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform4fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_4_1_Core->ProgramUniform4f(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform4iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_4_1_Core->ProgramUniform4i(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform3uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_4_1_Core->ProgramUniform3ui(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform3dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
 {
-    d_4_1_Core->ProgramUniform3d(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform3fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_4_1_Core->ProgramUniform3f(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform3iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_4_1_Core->ProgramUniform3i(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform2uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
 {
-    d_4_1_Core->ProgramUniform2ui(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform2dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
 {
-    d_4_1_Core->ProgramUniform2d(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform2fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
 {
-    d_4_1_Core->ProgramUniform2f(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform2iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
 {
-    d_4_1_Core->ProgramUniform2i(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform1uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
 {
-    d_4_1_Core->ProgramUniform1ui(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform1dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
 {
-    d_4_1_Core->ProgramUniform1d(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform1fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
 {
-    d_4_1_Core->ProgramUniform1f(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform1iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramUniform1i(GLuint program, GLint location, GLint v0)
 {
-    d_4_1_Core->ProgramUniform1i(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
 {
-    d_4_1_Core->GetProgramPipelineiv(pipeline, pname, params);
+    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsProgramPipeline(GLuint pipeline)
 {
-    return d_4_1_Core->IsProgramPipeline(pipeline);
+    return d_4_1_Core->f.IsProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
 {
-    d_4_1_Core->GenProgramPipelines(n, pipelines);
+    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
 {
-    d_4_1_Core->DeleteProgramPipelines(n, pipelines);
+    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBindProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->BindProgramPipeline(pipeline);
+    d_4_1_Core->f.BindProgramPipeline(pipeline);
 }
 
 inline GLuint QOpenGLFunctions_4_2_Compatibility::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings)
 {
-    return d_4_1_Core->CreateShaderProgramv(type, count, strings);
+    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glActiveShaderProgram(GLuint pipeline, GLuint program)
 {
-    d_4_1_Core->ActiveShaderProgram(pipeline, program);
+    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
 {
-    d_4_1_Core->UseProgramStages(pipeline, stages, program);
+    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramParameteri(GLuint program, GLenum pname, GLint value)
 {
-    d_4_1_Core->ProgramParameteri(program, pname, value);
+    d_4_1_Core->f.ProgramParameteri(program, pname, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length)
 {
-    d_4_1_Core->ProgramBinary(program, binaryFormat, binary, length);
+    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
 {
-    d_4_1_Core->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
+    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glClearDepthf(GLfloat dd)
 {
-    d_4_1_Core->ClearDepthf(dd);
+    d_4_1_Core->f.ClearDepthf(dd);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDepthRangef(GLfloat n, GLfloat f)
 {
-    d_4_1_Core->DepthRangef(n, f);
+    d_4_1_Core->f.DepthRangef(n, f);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
 {
-    d_4_1_Core->GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length)
 {
-    d_4_1_Core->ShaderBinary(count, shaders, binaryformat, binary, length);
+    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glReleaseShaderCompiler()
 {
-    d_4_1_Core->ReleaseShaderCompiler();
+    d_4_1_Core->f.ReleaseShaderCompiler();
 }
 
 
 // OpenGL 4.2 core functions
 inline void QOpenGLFunctions_4_2_Compatibility::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
-    d_4_2_Core->TexStorage3D(target, levels, internalformat, width, height, depth);
+    d_4_2_Core->f.TexStorage3D(target, levels, internalformat, width, height, depth);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_4_2_Core->TexStorage2D(target, levels, internalformat, width, height);
+    d_4_2_Core->f.TexStorage2D(target, levels, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
 {
-    d_4_2_Core->TexStorage1D(target, levels, internalformat, width);
+    d_4_2_Core->f.TexStorage1D(target, levels, internalformat, width);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMemoryBarrier(GLbitfield barriers)
 {
-    d_4_2_Core->MemoryBarrier(barriers);
+    d_4_2_Core->f.MemoryBarrier(barriers);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
 {
-    d_4_2_Core->BindImageTexture(unit, texture, level, layered, layer, access, format);
+    d_4_2_Core->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
 {
-    d_4_2_Core->GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
+    d_4_2_Core->f.GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
 {
-    d_4_2_Core->GetInternalformativ(target, internalformat, pname, bufSize, params);
+    d_4_2_Core->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
 {
-    d_4_2_Core->DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
+    d_4_2_Core->f.DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
 {
-    d_4_2_Core->DrawTransformFeedbackInstanced(mode, id, instancecount);
+    d_4_2_Core->f.DrawTransformFeedbackInstanced(mode, id, instancecount);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
 {
-    d_4_2_Core->DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
+    d_4_2_Core->f.DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
 {
-    d_4_2_Core->DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
+    d_4_2_Core->f.DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
 {
-    d_4_2_Core->DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
+    d_4_2_Core->f.DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_4_2_Compatibility::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_4_2_Compatibility::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_4_2_Compatibility::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
 // OpenGL 1.1 deprecated functions
 inline void QOpenGLFunctions_4_2_Compatibility::glPushClientAttrib(GLbitfield mask)
 {
-    d_1_1_Deprecated->PushClientAttrib(mask);
+    d_1_1_Deprecated->f.PushClientAttrib(mask);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPopClientAttrib()
 {
-    d_1_1_Deprecated->PopClientAttrib();
+    d_1_1_Deprecated->f.PopClientAttrib();
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 {
-    d_1_1_Deprecated->PrioritizeTextures(n, textures, priorities);
+    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Compatibility::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-    return d_1_1_Deprecated->AreTexturesResident(n, textures, residences);
+    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->VertexPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->TexCoordPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->NormalPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->InterleavedArrays(format, stride, pointer);
+    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->IndexPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEnableClientState(GLenum array)
 {
-    d_1_1_Deprecated->EnableClientState(array);
+    d_1_1_Deprecated->f.EnableClientState(array);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->EdgeFlagPointer(stride, pointer);
+    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glDisableClientState(GLenum array)
 {
-    d_1_1_Deprecated->DisableClientState(array);
+    d_1_1_Deprecated->f.DisableClientState(array);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->ColorPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glArrayElement(GLint i)
 {
-    d_1_1_Deprecated->ArrayElement(i);
+    d_1_1_Deprecated->f.ArrayElement(i);
 }
 
 
 // OpenGL 1.2 deprecated functions
 inline void QOpenGLFunctions_4_2_Compatibility::glResetMinmax(GLenum target)
 {
-    d_1_2_Deprecated->ResetMinmax(target);
+    d_1_2_Deprecated->f.ResetMinmax(target);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glResetHistogram(GLenum target)
 {
-    d_1_2_Deprecated->ResetHistogram(target);
+    d_1_2_Deprecated->f.ResetHistogram(target);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Minmax(target, internalformat, sink);
+    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Histogram(target, width, internalformat, sink);
+    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetMinmax(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetHistogramParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetHistogramParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetHistogram(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
 {
-    d_1_2_Deprecated->SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
+    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
 {
-    d_1_2_Deprecated->GetSeparableFilter(target, format, type, row, column, span);
+    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
 {
-    d_1_2_Deprecated->GetConvolutionFilter(target, format, type, image);
+    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
+    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter1D(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
 {
-    d_1_2_Deprecated->ConvolutionParameteri(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
 {
-    d_1_2_Deprecated->ConvolutionParameterf(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter1D(target, internalformat, width, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorSubTable(target, start, x, y, width);
+    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
 {
-    d_1_2_Deprecated->ColorSubTable(target, start, count, format, type, data);
+    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
 {
-    d_1_2_Deprecated->GetColorTable(target, format, type, table);
+    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorTable(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
 {
-    d_1_2_Deprecated->ColorTable(target, internalformat, width, format, type, table);
+    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
 }
 
 
 // OpenGL 1.3 deprecated functions
 inline void QOpenGLFunctions_4_2_Compatibility::glMultTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixd(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixf(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLoadTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixd(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glLoadTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixf(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord4sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_3_Deprecated->MultiTexCoord4s(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord4iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_3_Deprecated->MultiTexCoord4i(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_3_Deprecated->MultiTexCoord4f(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_3_Deprecated->MultiTexCoord4d(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord3sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
 {
-    d_1_3_Deprecated->MultiTexCoord3s(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord3iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
 {
-    d_1_3_Deprecated->MultiTexCoord3i(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_3_Deprecated->MultiTexCoord3f(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_3_Deprecated->MultiTexCoord3d(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord2sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
 {
-    d_1_3_Deprecated->MultiTexCoord2s(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord2iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
 {
-    d_1_3_Deprecated->MultiTexCoord2i(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
 {
-    d_1_3_Deprecated->MultiTexCoord2f(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
 {
-    d_1_3_Deprecated->MultiTexCoord2d(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord1sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord1s(GLenum target, GLshort s)
 {
-    d_1_3_Deprecated->MultiTexCoord1s(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord1iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord1i(GLenum target, GLint s)
 {
-    d_1_3_Deprecated->MultiTexCoord1i(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord1f(GLenum target, GLfloat s)
 {
-    d_1_3_Deprecated->MultiTexCoord1f(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glMultiTexCoord1d(GLenum target, GLdouble s)
 {
-    d_1_3_Deprecated->MultiTexCoord1d(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glClientActiveTexture(GLenum texture)
 {
-    d_1_3_Deprecated->ClientActiveTexture(texture);
+    d_1_3_Deprecated->f.ClientActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 deprecated functions
 inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos3sv(v);
+    d_1_4_Deprecated->f.WindowPos3sv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_4_Deprecated->WindowPos3s(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos3iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos3iv(v);
+    d_1_4_Deprecated->f.WindowPos3iv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_4_Deprecated->WindowPos3i(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos3fv(v);
+    d_1_4_Deprecated->f.WindowPos3fv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_4_Deprecated->WindowPos3f(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos3dv(v);
+    d_1_4_Deprecated->f.WindowPos3dv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_4_Deprecated->WindowPos3d(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos2sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos2sv(v);
+    d_1_4_Deprecated->f.WindowPos2sv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos2s(GLshort x, GLshort y)
 {
-    d_1_4_Deprecated->WindowPos2s(x, y);
+    d_1_4_Deprecated->f.WindowPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos2iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos2iv(v);
+    d_1_4_Deprecated->f.WindowPos2iv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos2i(GLint x, GLint y)
 {
-    d_1_4_Deprecated->WindowPos2i(x, y);
+    d_1_4_Deprecated->f.WindowPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos2fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos2fv(v);
+    d_1_4_Deprecated->f.WindowPos2fv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos2f(GLfloat x, GLfloat y)
 {
-    d_1_4_Deprecated->WindowPos2f(x, y);
+    d_1_4_Deprecated->f.WindowPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos2dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos2dv(v);
+    d_1_4_Deprecated->f.WindowPos2dv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glWindowPos2d(GLdouble x, GLdouble y)
 {
-    d_1_4_Deprecated->WindowPos2d(x, y);
+    d_1_4_Deprecated->f.WindowPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->SecondaryColorPointer(size, type, stride, pointer);
+    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3usv(const GLushort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3usv(v);
+    d_1_4_Deprecated->f.SecondaryColor3usv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3us(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3uiv(const GLuint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3uiv(v);
+    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ui(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3ubv(const GLubyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3ubv(v);
+    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ub(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3sv(v);
+    d_1_4_Deprecated->f.SecondaryColor3sv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3s(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3iv(const GLint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3iv(v);
+    d_1_4_Deprecated->f.SecondaryColor3iv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3i(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->SecondaryColor3fv(v);
+    d_1_4_Deprecated->f.SecondaryColor3fv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_4_Deprecated->SecondaryColor3f(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->SecondaryColor3dv(v);
+    d_1_4_Deprecated->f.SecondaryColor3dv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_4_Deprecated->SecondaryColor3d(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3bv(const GLbyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3bv(v);
+    d_1_4_Deprecated->f.SecondaryColor3bv(v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3b(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->FogCoordPointer(type, stride, pointer);
+    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFogCoorddv(const GLdouble *coord)
 {
-    d_1_4_Deprecated->FogCoorddv(coord);
+    d_1_4_Deprecated->f.FogCoorddv(coord);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFogCoordd(GLdouble coord)
 {
-    d_1_4_Deprecated->FogCoordd(coord);
+    d_1_4_Deprecated->f.FogCoordd(coord);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFogCoordfv(const GLfloat *coord)
 {
-    d_1_4_Deprecated->FogCoordfv(coord);
+    d_1_4_Deprecated->f.FogCoordfv(coord);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glFogCoordf(GLfloat coord)
 {
-    d_1_4_Deprecated->FogCoordf(coord);
+    d_1_4_Deprecated->f.FogCoordf(coord);
 }
 
 
@@ -5333,182 +5334,182 @@ inline void QOpenGLFunctions_4_2_Compatibility::glFogCoordf(GLfloat coord)
 // OpenGL 2.0 deprecated functions
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4usv(index, v);
+    d_2_0_Core->f.VertexAttrib4usv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4uiv(index, v);
+    d_2_0_Core->f.VertexAttrib4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4ubv(index, v);
+    d_2_0_Core->f.VertexAttrib4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4sv(index, v);
+    d_2_0_Core->f.VertexAttrib4sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4iv(index, v);
+    d_2_0_Core->f.VertexAttrib4iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib4fv(index, v);
+    d_2_0_Core->f.VertexAttrib4fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib4dv(index, v);
+    d_2_0_Core->f.VertexAttrib4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4bv(index, v);
+    d_2_0_Core->f.VertexAttrib4bv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4Nusv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4Nuiv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nubv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
 {
-    d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4Nsv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4Niv(index, v);
+    d_2_0_Core->f.VertexAttrib4Niv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nbv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib3sv(index, v);
+    d_2_0_Core->f.VertexAttrib3sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
 {
-    d_2_0_Core->VertexAttrib3s(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib3fv(index, v);
+    d_2_0_Core->f.VertexAttrib3fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_2_0_Core->VertexAttrib3f(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib3dv(index, v);
+    d_2_0_Core->f.VertexAttrib3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_2_0_Core->VertexAttrib3d(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib2sv(index, v);
+    d_2_0_Core->f.VertexAttrib2sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
 {
-    d_2_0_Core->VertexAttrib2s(index, x, y);
+    d_2_0_Core->f.VertexAttrib2s(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib2fv(index, v);
+    d_2_0_Core->f.VertexAttrib2fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
 {
-    d_2_0_Core->VertexAttrib2f(index, x, y);
+    d_2_0_Core->f.VertexAttrib2f(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib2dv(index, v);
+    d_2_0_Core->f.VertexAttrib2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_2_0_Core->VertexAttrib2d(index, x, y);
+    d_2_0_Core->f.VertexAttrib2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib1sv(index, v);
+    d_2_0_Core->f.VertexAttrib1sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
 {
-    d_2_0_Core->VertexAttrib1s(index, x);
+    d_2_0_Core->f.VertexAttrib1s(index, x);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib1fv(index, v);
+    d_2_0_Core->f.VertexAttrib1fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
 {
-    d_2_0_Core->VertexAttrib1f(index, x);
+    d_2_0_Core->f.VertexAttrib1f(index, x);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib1dv(index, v);
+    d_2_0_Core->f.VertexAttrib1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
 {
-    d_2_0_Core->VertexAttrib1d(index, x);
+    d_2_0_Core->f.VertexAttrib1d(index, x);
 }
 
 
@@ -5517,102 +5518,102 @@ inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttrib1d(GLuint index, G
 // OpenGL 3.0 deprecated functions
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
 {
-    d_3_0_Core->VertexAttribI4usv(index, v);
+    d_3_0_Core->f.VertexAttribI4usv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
 {
-    d_3_0_Core->VertexAttribI4ubv(index, v);
+    d_3_0_Core->f.VertexAttribI4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
 {
-    d_3_0_Core->VertexAttribI4sv(index, v);
+    d_3_0_Core->f.VertexAttribI4sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
 {
-    d_3_0_Core->VertexAttribI4bv(index, v);
+    d_3_0_Core->f.VertexAttribI4bv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI4uiv(index, v);
+    d_3_0_Core->f.VertexAttribI4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI3uiv(index, v);
+    d_3_0_Core->f.VertexAttribI3uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI2uiv(index, v);
+    d_3_0_Core->f.VertexAttribI2uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI1uiv(index, v);
+    d_3_0_Core->f.VertexAttribI1uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI4iv(index, v);
+    d_3_0_Core->f.VertexAttribI4iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI3iv(index, v);
+    d_3_0_Core->f.VertexAttribI3iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI2iv(index, v);
+    d_3_0_Core->f.VertexAttribI2iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI1iv(index, v);
+    d_3_0_Core->f.VertexAttribI1iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
 {
-    d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
 {
-    d_3_0_Core->VertexAttribI3ui(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
 {
-    d_3_0_Core->VertexAttribI2ui(index, x, y);
+    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
 {
-    d_3_0_Core->VertexAttribI1ui(index, x);
+    d_3_0_Core->f.VertexAttribI1ui(index, x);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
 {
-    d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
 {
-    d_3_0_Core->VertexAttribI3i(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
 {
-    d_3_0_Core->VertexAttribI2i(index, x, y);
+    d_3_0_Core->f.VertexAttribI2i(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
 {
-    d_3_0_Core->VertexAttribI1i(index, x);
+    d_3_0_Core->f.VertexAttribI1i(index, x);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_4_2_core.cpp b/src/gui/opengl/qopenglfunctions_4_2_core.cpp
index 800d4679c5e..b929abcf6a5 100644
--- a/src/gui/opengl/qopenglfunctions_4_2_core.cpp
+++ b/src/gui/opengl/qopenglfunctions_4_2_core.cpp
@@ -87,66 +87,51 @@ QOpenGLFunctions_4_2_Core::QOpenGLFunctions_4_2_Core()
 
 QOpenGLFunctions_4_2_Core::~QOpenGLFunctions_4_2_Core()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
-    if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        delete d_3_2_Core;
-    }
-    if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        delete d_3_3_Core;
-    }
-    if (d_4_0_Core && !d_4_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_0_Core->context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        delete d_4_0_Core;
-    }
-    if (d_4_1_Core && !d_4_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_1_Core->context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        delete d_4_1_Core;
-    }
-    if (d_4_2_Core && !d_4_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_2_Core->context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        delete d_4_2_Core;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
+    if (d_3_2_Core)
+        d_3_2_Core->refs.deref();
+    Q_ASSERT(d_3_2_Core->refs.load());
+    if (d_3_3_Core)
+        d_3_3_Core->refs.deref();
+    Q_ASSERT(d_3_3_Core->refs.load());
+    if (d_4_0_Core)
+        d_4_0_Core->refs.deref();
+    Q_ASSERT(d_4_0_Core->refs.load());
+    if (d_4_1_Core)
+        d_4_1_Core->refs.deref();
+    Q_ASSERT(d_4_1_Core->refs.load());
+    if (d_4_2_Core)
+        d_4_2_Core->refs.deref();
+    Q_ASSERT(d_4_2_Core->refs.load());
 }
 
 bool QOpenGLFunctions_4_2_Core::initializeOpenGLFunctions()
@@ -165,122 +150,62 @@ bool QOpenGLFunctions_4_2_Core::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
-        }
         d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
-        }
         d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus(), d);
-        }
         d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus(), d);
-        }
         d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus(), d);
-        }
         d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_4_2_core.h b/src/gui/opengl/qopenglfunctions_4_2_core.h
index 173eb9e9eca..14b748b3f58 100644
--- a/src/gui/opengl/qopenglfunctions_4_2_core.h
+++ b/src/gui/opengl/qopenglfunctions_4_2_core.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -589,242 +590,242 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_4_2_Core::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Core::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_2_Core::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_4_2_Core::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_4_2_Core::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_4_2_Core::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
@@ -843,57 +844,57 @@ inline void QOpenGLFunctions_4_2_Core::glIndexub(GLubyte c)
 
 inline GLboolean QOpenGLFunctions_4_2_Core::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetPointerv(GLenum pname, GLvoid* *params)
@@ -905,1067 +906,1067 @@ inline void QOpenGLFunctions_4_2_Core::glGetPointerv(GLenum pname, GLvoid* *para
 
 inline void QOpenGLFunctions_4_2_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_4_2_Core::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_4_2_Core::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_4_2_Core::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_4_2_Core::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Core::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_4_2_Core::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Core::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Core::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Core::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Core::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_4_2_Core::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_4_2_Core::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, obj);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_4_2_Core::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_4_2_Core::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_4_2_Core::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_4_2_Core::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline GLvoid* QOpenGLFunctions_4_2_Core::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_4_2_Core::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Core::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Core::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_2_Core::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_4_2_Core::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Core::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_4_2_Core::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_4_2_Core::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
 // OpenGL 3.2 core functions
 inline void QOpenGLFunctions_4_2_Core::glSampleMaski(GLuint index, GLbitfield mask)
 {
-    d_3_2_Core->SampleMaski(index, mask);
+    d_3_2_Core->f.SampleMaski(index, mask);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
 {
-    d_3_2_Core->GetMultisamplefv(pname, index, val);
+    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
-    d_3_2_Core->GetSynciv(sync, pname, bufSize, length, values);
+    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetInteger64v(GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetInteger64v(pname, params);
+    d_3_2_Core->f.GetInteger64v(pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    d_3_2_Core->WaitSync(sync, flags, timeout);
+    d_3_2_Core->f.WaitSync(sync, flags, timeout);
 }
 
 inline GLenum QOpenGLFunctions_4_2_Core::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    return d_3_2_Core->ClientWaitSync(sync, flags, timeout);
+    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDeleteSync(GLsync sync)
 {
-    d_3_2_Core->DeleteSync(sync);
+    d_3_2_Core->f.DeleteSync(sync);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Core::glIsSync(GLsync sync)
 {
-    return d_3_2_Core->IsSync(sync);
+    return d_3_2_Core->f.IsSync(sync);
 }
 
 inline GLsync QOpenGLFunctions_4_2_Core::glFenceSync(GLenum condition, GLbitfield flags)
 {
-    return d_3_2_Core->FenceSync(condition, flags);
+    return d_3_2_Core->f.FenceSync(condition, flags);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProvokingVertex(GLenum mode)
 {
-    d_3_2_Core->ProvokingVertex(mode);
+    d_3_2_Core->f.ProvokingVertex(mode);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
 {
-    d_3_2_Core->MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
-    d_3_2_Core->FramebufferTexture(target, attachment, texture, level);
+    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetBufferParameteri64v(target, pname, params);
+    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64i_v(target, index, data);
+    d_3_2_Core->f.GetInteger64i_v(target, index, data);
 }
 
 
 // OpenGL 3.3 core functions
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP4uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP4ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP3uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP3ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP2uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP2ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP1uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP1ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
@@ -2188,838 +2189,838 @@ inline void QOpenGLFunctions_4_2_Core::glVertexP2ui(GLenum type, GLuint value)
 
 inline void QOpenGLFunctions_4_2_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
 {
-    d_3_3_Core->GetQueryObjectui64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
 {
-    d_3_3_Core->GetQueryObjecti64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glQueryCounter(GLuint id, GLenum target)
 {
-    d_3_3_Core->QueryCounter(id, target);
+    d_3_3_Core->f.QueryCounter(id, target);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
 {
-    d_3_3_Core->GetSamplerParameterIuiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
 {
-    d_3_3_Core->GetSamplerParameterfv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameterIiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameteriv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
 {
-    d_3_3_Core->SamplerParameterIuiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameterIiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
 {
-    d_3_3_Core->SamplerParameterfv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
 {
-    d_3_3_Core->SamplerParameterf(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameteriv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
-    d_3_3_Core->SamplerParameteri(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBindSampler(GLuint unit, GLuint sampler)
 {
-    d_3_3_Core->BindSampler(unit, sampler);
+    d_3_3_Core->f.BindSampler(unit, sampler);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Core::glIsSampler(GLuint sampler)
 {
-    return d_3_3_Core->IsSampler(sampler);
+    return d_3_3_Core->f.IsSampler(sampler);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDeleteSamplers(GLsizei count, const GLuint *samplers)
 {
-    d_3_3_Core->DeleteSamplers(count, samplers);
+    d_3_3_Core->f.DeleteSamplers(count, samplers);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGenSamplers(GLsizei count, GLuint *samplers)
 {
-    d_3_3_Core->GenSamplers(count, samplers);
+    d_3_3_Core->f.GenSamplers(count, samplers);
 }
 
 inline GLint QOpenGLFunctions_4_2_Core::glGetFragDataIndex(GLuint program, const GLchar *name)
 {
-    return d_3_3_Core->GetFragDataIndex(program, name);
+    return d_3_3_Core->f.GetFragDataIndex(program, name);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
 {
-    d_3_3_Core->BindFragDataLocationIndexed(program, colorNumber, index, name);
+    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribDivisor(GLuint index, GLuint divisor)
 {
-    d_3_3_Core->VertexAttribDivisor(index, divisor);
+    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
 }
 
 
 // OpenGL 4.0 core functions
 inline void QOpenGLFunctions_4_2_Core::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
 {
-    d_4_0_Core->GetQueryIndexediv(target, index, pname, params);
+    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glEndQueryIndexed(GLenum target, GLuint index)
 {
-    d_4_0_Core->EndQueryIndexed(target, index);
+    d_4_0_Core->f.EndQueryIndexed(target, index);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
 {
-    d_4_0_Core->BeginQueryIndexed(target, index, id);
+    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
 {
-    d_4_0_Core->DrawTransformFeedbackStream(mode, id, stream);
+    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawTransformFeedback(GLenum mode, GLuint id)
 {
-    d_4_0_Core->DrawTransformFeedback(mode, id);
+    d_4_0_Core->f.DrawTransformFeedback(mode, id);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glResumeTransformFeedback()
 {
-    d_4_0_Core->ResumeTransformFeedback();
+    d_4_0_Core->f.ResumeTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_2_Core::glPauseTransformFeedback()
 {
-    d_4_0_Core->PauseTransformFeedback();
+    d_4_0_Core->f.PauseTransformFeedback();
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Core::glIsTransformFeedback(GLuint id)
 {
-    return d_4_0_Core->IsTransformFeedback(id);
+    return d_4_0_Core->f.IsTransformFeedback(id);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
 {
-    d_4_0_Core->GenTransformFeedbacks(n, ids);
+    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
 {
-    d_4_0_Core->DeleteTransformFeedbacks(n, ids);
+    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBindTransformFeedback(GLenum target, GLuint id)
 {
-    d_4_0_Core->BindTransformFeedback(target, id);
+    d_4_0_Core->f.BindTransformFeedback(target, id);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glPatchParameterfv(GLenum pname, const GLfloat *values)
 {
-    d_4_0_Core->PatchParameterfv(pname, values);
+    d_4_0_Core->f.PatchParameterfv(pname, values);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glPatchParameteri(GLenum pname, GLint value)
 {
-    d_4_0_Core->PatchParameteri(pname, value);
+    d_4_0_Core->f.PatchParameteri(pname, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetProgramStageiv(program, shadertype, pname, values);
+    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
 {
-    d_4_0_Core->GetUniformSubroutineuiv(shadertype, location, params);
+    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
 {
-    d_4_0_Core->UniformSubroutinesuiv(shadertype, count, indices);
+    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
+    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
 }
 
 inline GLuint QOpenGLFunctions_4_2_Core::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineIndex(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
 }
 
 inline GLint QOpenGLFunctions_4_2_Core::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineUniformLocation(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
 {
-    d_4_0_Core->GetUniformdv(program, location, params);
+    d_4_0_Core->f.GetUniformdv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform4dv(location, count, value);
+    d_4_0_Core->f.Uniform4dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform3dv(location, count, value);
+    d_4_0_Core->f.Uniform3dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform2dv(location, count, value);
+    d_4_0_Core->f.Uniform2dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform1dv(location, count, value);
+    d_4_0_Core->f.Uniform1dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_0_Core->Uniform4d(location, x, y, z, w);
+    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_0_Core->Uniform3d(location, x, y, z);
+    d_4_0_Core->f.Uniform3d(location, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform2d(GLint location, GLdouble x, GLdouble y)
 {
-    d_4_0_Core->Uniform2d(location, x, y);
+    d_4_0_Core->f.Uniform2d(location, x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUniform1d(GLint location, GLdouble x)
 {
-    d_4_0_Core->Uniform1d(location, x);
+    d_4_0_Core->f.Uniform1d(location, x);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
 {
-    d_4_0_Core->DrawElementsIndirect(mode, type, indirect);
+    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawArraysIndirect(GLenum mode, const GLvoid *indirect)
 {
-    d_4_0_Core->DrawArraysIndirect(mode, indirect);
+    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-    d_4_0_Core->BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
 {
-    d_4_0_Core->BlendFunci(buf, src, dst);
+    d_4_0_Core->f.BlendFunci(buf, src, dst);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
 {
-    d_4_0_Core->BlendEquationSeparatei(buf, modeRGB, modeAlpha);
+    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBlendEquationi(GLuint buf, GLenum mode)
 {
-    d_4_0_Core->BlendEquationi(buf, mode);
+    d_4_0_Core->f.BlendEquationi(buf, mode);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glMinSampleShading(GLfloat value)
 {
-    d_4_0_Core->MinSampleShading(value);
+    d_4_0_Core->f.MinSampleShading(value);
 }
 
 
 // OpenGL 4.1 core functions
 inline void QOpenGLFunctions_4_2_Core::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
 {
-    d_4_1_Core->GetDoublei_v(target, index, data);
+    d_4_1_Core->f.GetDoublei_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
 {
-    d_4_1_Core->GetFloati_v(target, index, data);
+    d_4_1_Core->f.GetFloati_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
 {
-    d_4_1_Core->DepthRangeIndexed(index, n, f);
+    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
 {
-    d_4_1_Core->DepthRangeArrayv(first, count, v);
+    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glScissorIndexedv(GLuint index, const GLint *v)
 {
-    d_4_1_Core->ScissorIndexedv(index, v);
+    d_4_1_Core->f.ScissorIndexedv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
 {
-    d_4_1_Core->ScissorIndexed(index, left, bottom, width, height);
+    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
 {
-    d_4_1_Core->ScissorArrayv(first, count, v);
+    d_4_1_Core->f.ScissorArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glViewportIndexedfv(GLuint index, const GLfloat *v)
 {
-    d_4_1_Core->ViewportIndexedfv(index, v);
+    d_4_1_Core->f.ViewportIndexedfv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
 {
-    d_4_1_Core->ViewportIndexedf(index, x, y, w, h);
+    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
 {
-    d_4_1_Core->ViewportArrayv(first, count, v);
+    d_4_1_Core->f.ViewportArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_4_1_Core->GetVertexAttribLdv(index, pname, params);
+    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_4_1_Core->VertexAttribLPointer(index, size, type, stride, pointer);
+    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribL4dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL4dv(index, v);
+    d_4_1_Core->f.VertexAttribL4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribL3dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL3dv(index, v);
+    d_4_1_Core->f.VertexAttribL3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribL2dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL2dv(index, v);
+    d_4_1_Core->f.VertexAttribL2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribL1dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL1dv(index, v);
+    d_4_1_Core->f.VertexAttribL1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_1_Core->VertexAttribL4d(index, x, y, z, w);
+    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_1_Core->VertexAttribL3d(index, x, y, z);
+    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_4_1_Core->VertexAttribL2d(index, x, y);
+    d_4_1_Core->f.VertexAttribL2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glVertexAttribL1d(GLuint index, GLdouble x)
 {
-    d_4_1_Core->VertexAttribL1d(index, x);
+    d_4_1_Core->f.VertexAttribL1d(index, x);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_4_1_Core->GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glValidateProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->ValidateProgramPipeline(pipeline);
+    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform4uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_4_1_Core->ProgramUniform4ui(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform4dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
 {
-    d_4_1_Core->ProgramUniform4d(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform4fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_4_1_Core->ProgramUniform4f(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform4iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_4_1_Core->ProgramUniform4i(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform3uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_4_1_Core->ProgramUniform3ui(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform3dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
 {
-    d_4_1_Core->ProgramUniform3d(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform3fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_4_1_Core->ProgramUniform3f(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform3iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_4_1_Core->ProgramUniform3i(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform2uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
 {
-    d_4_1_Core->ProgramUniform2ui(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform2dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
 {
-    d_4_1_Core->ProgramUniform2d(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform2fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
 {
-    d_4_1_Core->ProgramUniform2f(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform2iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
 {
-    d_4_1_Core->ProgramUniform2i(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform1uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
 {
-    d_4_1_Core->ProgramUniform1ui(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform1dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
 {
-    d_4_1_Core->ProgramUniform1d(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform1fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
 {
-    d_4_1_Core->ProgramUniform1f(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform1iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramUniform1i(GLuint program, GLint location, GLint v0)
 {
-    d_4_1_Core->ProgramUniform1i(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
 {
-    d_4_1_Core->GetProgramPipelineiv(pipeline, pname, params);
+    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_2_Core::glIsProgramPipeline(GLuint pipeline)
 {
-    return d_4_1_Core->IsProgramPipeline(pipeline);
+    return d_4_1_Core->f.IsProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
 {
-    d_4_1_Core->GenProgramPipelines(n, pipelines);
+    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
 {
-    d_4_1_Core->DeleteProgramPipelines(n, pipelines);
+    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBindProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->BindProgramPipeline(pipeline);
+    d_4_1_Core->f.BindProgramPipeline(pipeline);
 }
 
 inline GLuint QOpenGLFunctions_4_2_Core::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings)
 {
-    return d_4_1_Core->CreateShaderProgramv(type, count, strings);
+    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glActiveShaderProgram(GLuint pipeline, GLuint program)
 {
-    d_4_1_Core->ActiveShaderProgram(pipeline, program);
+    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
 {
-    d_4_1_Core->UseProgramStages(pipeline, stages, program);
+    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramParameteri(GLuint program, GLenum pname, GLint value)
 {
-    d_4_1_Core->ProgramParameteri(program, pname, value);
+    d_4_1_Core->f.ProgramParameteri(program, pname, value);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length)
 {
-    d_4_1_Core->ProgramBinary(program, binaryFormat, binary, length);
+    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
 {
-    d_4_1_Core->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
+    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glClearDepthf(GLfloat dd)
 {
-    d_4_1_Core->ClearDepthf(dd);
+    d_4_1_Core->f.ClearDepthf(dd);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDepthRangef(GLfloat n, GLfloat f)
 {
-    d_4_1_Core->DepthRangef(n, f);
+    d_4_1_Core->f.DepthRangef(n, f);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
 {
-    d_4_1_Core->GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length)
 {
-    d_4_1_Core->ShaderBinary(count, shaders, binaryformat, binary, length);
+    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glReleaseShaderCompiler()
 {
-    d_4_1_Core->ReleaseShaderCompiler();
+    d_4_1_Core->f.ReleaseShaderCompiler();
 }
 
 
 // OpenGL 4.2 core functions
 inline void QOpenGLFunctions_4_2_Core::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
-    d_4_2_Core->TexStorage3D(target, levels, internalformat, width, height, depth);
+    d_4_2_Core->f.TexStorage3D(target, levels, internalformat, width, height, depth);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_4_2_Core->TexStorage2D(target, levels, internalformat, width, height);
+    d_4_2_Core->f.TexStorage2D(target, levels, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
 {
-    d_4_2_Core->TexStorage1D(target, levels, internalformat, width);
+    d_4_2_Core->f.TexStorage1D(target, levels, internalformat, width);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glMemoryBarrier(GLbitfield barriers)
 {
-    d_4_2_Core->MemoryBarrier(barriers);
+    d_4_2_Core->f.MemoryBarrier(barriers);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
 {
-    d_4_2_Core->BindImageTexture(unit, texture, level, layered, layer, access, format);
+    d_4_2_Core->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
 {
-    d_4_2_Core->GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
+    d_4_2_Core->f.GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
 {
-    d_4_2_Core->GetInternalformativ(target, internalformat, pname, bufSize, params);
+    d_4_2_Core->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
 {
-    d_4_2_Core->DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
+    d_4_2_Core->f.DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
 {
-    d_4_2_Core->DrawTransformFeedbackInstanced(mode, id, instancecount);
+    d_4_2_Core->f.DrawTransformFeedbackInstanced(mode, id, instancecount);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
 {
-    d_4_2_Core->DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
+    d_4_2_Core->f.DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
 {
-    d_4_2_Core->DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
+    d_4_2_Core->f.DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
 }
 
 inline void QOpenGLFunctions_4_2_Core::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
 {
-    d_4_2_Core->DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
+    d_4_2_Core->f.DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_4_3_compatibility.cpp b/src/gui/opengl/qopenglfunctions_4_3_compatibility.cpp
index 0cf5c467ea4..a9f15083adf 100644
--- a/src/gui/opengl/qopenglfunctions_4_3_compatibility.cpp
+++ b/src/gui/opengl/qopenglfunctions_4_3_compatibility.cpp
@@ -95,94 +95,72 @@ QOpenGLFunctions_4_3_Compatibility::QOpenGLFunctions_4_3_Compatibility()
 
 QOpenGLFunctions_4_3_Compatibility::~QOpenGLFunctions_4_3_Compatibility()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
-    if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        delete d_3_2_Core;
-    }
-    if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        delete d_3_3_Core;
-    }
-    if (d_4_0_Core && !d_4_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_0_Core->context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        delete d_4_0_Core;
-    }
-    if (d_4_1_Core && !d_4_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_1_Core->context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        delete d_4_1_Core;
-    }
-    if (d_4_2_Core && !d_4_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_2_Core->context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        delete d_4_2_Core;
-    }
-    if (d_4_3_Core && !d_4_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_3_Core->context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        delete d_4_3_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
-    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        delete d_1_1_Deprecated;
-    }
-    if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        delete d_1_2_Deprecated;
-    }
-    if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        delete d_1_3_Deprecated;
-    }
-    if (d_1_4_Deprecated && !d_1_4_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        delete d_1_4_Deprecated;
-    }
-    if (d_3_3_Deprecated && !d_3_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Deprecated->context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        delete d_3_3_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
+    if (d_3_2_Core)
+        d_3_2_Core->refs.deref();
+    Q_ASSERT(d_3_2_Core->refs.load());
+    if (d_3_3_Core)
+        d_3_3_Core->refs.deref();
+    Q_ASSERT(d_3_3_Core->refs.load());
+    if (d_4_0_Core)
+        d_4_0_Core->refs.deref();
+    Q_ASSERT(d_4_0_Core->refs.load());
+    if (d_4_1_Core)
+        d_4_1_Core->refs.deref();
+    Q_ASSERT(d_4_1_Core->refs.load());
+    if (d_4_2_Core)
+        d_4_2_Core->refs.deref();
+    Q_ASSERT(d_4_2_Core->refs.load());
+    if (d_4_3_Core)
+        d_4_3_Core->refs.deref();
+    Q_ASSERT(d_4_3_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
+    if (d_1_1_Deprecated)
+        d_1_1_Deprecated->refs.deref();
+    Q_ASSERT(d_1_1_Deprecated->refs.load());
+    if (d_1_2_Deprecated)
+        d_1_2_Deprecated->refs.deref();
+    Q_ASSERT(d_1_2_Deprecated->refs.load());
+    if (d_1_3_Deprecated)
+        d_1_3_Deprecated->refs.deref();
+    Q_ASSERT(d_1_3_Deprecated->refs.load());
+    if (d_1_4_Deprecated)
+        d_1_4_Deprecated->refs.deref();
+    Q_ASSERT(d_1_4_Deprecated->refs.load());
+    if (d_3_3_Deprecated)
+        d_3_3_Deprecated->refs.deref();
+    Q_ASSERT(d_3_3_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_4_3_Compatibility::initializeOpenGLFunctions()
@@ -201,178 +179,90 @@ bool QOpenGLFunctions_4_3_Compatibility::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
-        }
         d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
-        }
         d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus(), d);
-        }
         d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus(), d);
-        }
         d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus(), d);
-        }
         d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus(), d);
-        }
         d_4_3_Core = static_cast<QOpenGLFunctions_4_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_4_3_compatibility.h b/src/gui/opengl/qopenglfunctions_4_3_compatibility.h
index 366da302ed7..33d3065500e 100644
--- a/src/gui/opengl/qopenglfunctions_4_3_compatibility.h
+++ b/src/gui/opengl/qopenglfunctions_4_3_compatibility.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -1099,4437 +1100,4437 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_4_3_Compatibility::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_3_Compatibility::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_4_3_Compatibility::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline void QOpenGLFunctions_4_3_Compatibility::glIndexubv(const GLubyte *c)
 {
-    d_1_1_Deprecated->Indexubv(c);
+    d_1_1_Deprecated->f.Indexubv(c);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glIndexub(GLubyte c)
 {
-    d_1_1_Deprecated->Indexub(c);
+    d_1_1_Deprecated->f.Indexub(c);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetPointerv(GLenum pname, GLvoid* *params)
 {
-    d_1_1_Deprecated->GetPointerv(pname, params);
+    d_1_1_Deprecated->f.GetPointerv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_4_3_Compatibility::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_4_3_Compatibility::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_4_3_Compatibility::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_4_3_Compatibility::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_4_3_Compatibility::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_4_3_Compatibility::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_4_3_Compatibility::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, obj);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_4_3_Compatibility::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_4_3_Compatibility::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline GLvoid* QOpenGLFunctions_4_3_Compatibility::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_4_3_Compatibility::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_3_Compatibility::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_4_3_Compatibility::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_4_3_Compatibility::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_4_3_Compatibility::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
 // OpenGL 3.2 core functions
 inline void QOpenGLFunctions_4_3_Compatibility::glSampleMaski(GLuint index, GLbitfield mask)
 {
-    d_3_2_Core->SampleMaski(index, mask);
+    d_3_2_Core->f.SampleMaski(index, mask);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
 {
-    d_3_2_Core->GetMultisamplefv(pname, index, val);
+    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
-    d_3_2_Core->GetSynciv(sync, pname, bufSize, length, values);
+    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetInteger64v(GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetInteger64v(pname, params);
+    d_3_2_Core->f.GetInteger64v(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    d_3_2_Core->WaitSync(sync, flags, timeout);
+    d_3_2_Core->f.WaitSync(sync, flags, timeout);
 }
 
 inline GLenum QOpenGLFunctions_4_3_Compatibility::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    return d_3_2_Core->ClientWaitSync(sync, flags, timeout);
+    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDeleteSync(GLsync sync)
 {
-    d_3_2_Core->DeleteSync(sync);
+    d_3_2_Core->f.DeleteSync(sync);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsSync(GLsync sync)
 {
-    return d_3_2_Core->IsSync(sync);
+    return d_3_2_Core->f.IsSync(sync);
 }
 
 inline GLsync QOpenGLFunctions_4_3_Compatibility::glFenceSync(GLenum condition, GLbitfield flags)
 {
-    return d_3_2_Core->FenceSync(condition, flags);
+    return d_3_2_Core->f.FenceSync(condition, flags);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProvokingVertex(GLenum mode)
 {
-    d_3_2_Core->ProvokingVertex(mode);
+    d_3_2_Core->f.ProvokingVertex(mode);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
 {
-    d_3_2_Core->MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
-    d_3_2_Core->FramebufferTexture(target, attachment, texture, level);
+    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetBufferParameteri64v(target, pname, params);
+    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64i_v(target, index, data);
+    d_3_2_Core->f.GetInteger64i_v(target, index, data);
 }
 
 
 // OpenGL 3.3 core functions
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP4uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP4ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP3uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP3ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP2uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP2ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP1uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP1ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->SecondaryColorP3uiv(type, color);
+    d_3_3_Deprecated->f.SecondaryColorP3uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->SecondaryColorP3ui(type, color);
+    d_3_3_Deprecated->f.SecondaryColorP3ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->ColorP4uiv(type, color);
+    d_3_3_Deprecated->f.ColorP4uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColorP4ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->ColorP4ui(type, color);
+    d_3_3_Deprecated->f.ColorP4ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->ColorP3uiv(type, color);
+    d_3_3_Deprecated->f.ColorP3uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColorP3ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->ColorP3ui(type, color);
+    d_3_3_Deprecated->f.ColorP3ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->NormalP3uiv(type, coords);
+    d_3_3_Deprecated->f.NormalP3uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->NormalP3ui(type, coords);
+    d_3_3_Deprecated->f.NormalP3ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP4uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP4uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP4ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP4ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP3uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP3uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP3ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP3ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP2uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP2uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP2ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP2ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP1uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP1uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP1ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP1ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP4uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP4uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP4ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP4ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP3uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP3uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP3ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP3ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP2uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP2uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP2ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP2ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP1uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP1uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP1ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP1ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP4uiv(type, value);
+    d_3_3_Deprecated->f.VertexP4uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexP4ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP4ui(type, value);
+    d_3_3_Deprecated->f.VertexP4ui(type, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP3uiv(type, value);
+    d_3_3_Deprecated->f.VertexP3uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexP3ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP3ui(type, value);
+    d_3_3_Deprecated->f.VertexP3ui(type, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP2uiv(type, value);
+    d_3_3_Deprecated->f.VertexP2uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexP2ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP2ui(type, value);
+    d_3_3_Deprecated->f.VertexP2ui(type, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
 {
-    d_3_3_Core->GetQueryObjectui64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
 {
-    d_3_3_Core->GetQueryObjecti64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glQueryCounter(GLuint id, GLenum target)
 {
-    d_3_3_Core->QueryCounter(id, target);
+    d_3_3_Core->f.QueryCounter(id, target);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
 {
-    d_3_3_Core->GetSamplerParameterIuiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
 {
-    d_3_3_Core->GetSamplerParameterfv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameterIiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameteriv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
 {
-    d_3_3_Core->SamplerParameterIuiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameterIiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
 {
-    d_3_3_Core->SamplerParameterfv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
 {
-    d_3_3_Core->SamplerParameterf(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameteriv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
-    d_3_3_Core->SamplerParameteri(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBindSampler(GLuint unit, GLuint sampler)
 {
-    d_3_3_Core->BindSampler(unit, sampler);
+    d_3_3_Core->f.BindSampler(unit, sampler);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsSampler(GLuint sampler)
 {
-    return d_3_3_Core->IsSampler(sampler);
+    return d_3_3_Core->f.IsSampler(sampler);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDeleteSamplers(GLsizei count, const GLuint *samplers)
 {
-    d_3_3_Core->DeleteSamplers(count, samplers);
+    d_3_3_Core->f.DeleteSamplers(count, samplers);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGenSamplers(GLsizei count, GLuint *samplers)
 {
-    d_3_3_Core->GenSamplers(count, samplers);
+    d_3_3_Core->f.GenSamplers(count, samplers);
 }
 
 inline GLint QOpenGLFunctions_4_3_Compatibility::glGetFragDataIndex(GLuint program, const GLchar *name)
 {
-    return d_3_3_Core->GetFragDataIndex(program, name);
+    return d_3_3_Core->f.GetFragDataIndex(program, name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
 {
-    d_3_3_Core->BindFragDataLocationIndexed(program, colorNumber, index, name);
+    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribDivisor(GLuint index, GLuint divisor)
 {
-    d_3_3_Core->VertexAttribDivisor(index, divisor);
+    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
 }
 
 
 // OpenGL 4.0 core functions
 inline void QOpenGLFunctions_4_3_Compatibility::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
 {
-    d_4_0_Core->GetQueryIndexediv(target, index, pname, params);
+    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEndQueryIndexed(GLenum target, GLuint index)
 {
-    d_4_0_Core->EndQueryIndexed(target, index);
+    d_4_0_Core->f.EndQueryIndexed(target, index);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
 {
-    d_4_0_Core->BeginQueryIndexed(target, index, id);
+    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
 {
-    d_4_0_Core->DrawTransformFeedbackStream(mode, id, stream);
+    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawTransformFeedback(GLenum mode, GLuint id)
 {
-    d_4_0_Core->DrawTransformFeedback(mode, id);
+    d_4_0_Core->f.DrawTransformFeedback(mode, id);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glResumeTransformFeedback()
 {
-    d_4_0_Core->ResumeTransformFeedback();
+    d_4_0_Core->f.ResumeTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPauseTransformFeedback()
 {
-    d_4_0_Core->PauseTransformFeedback();
+    d_4_0_Core->f.PauseTransformFeedback();
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsTransformFeedback(GLuint id)
 {
-    return d_4_0_Core->IsTransformFeedback(id);
+    return d_4_0_Core->f.IsTransformFeedback(id);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
 {
-    d_4_0_Core->GenTransformFeedbacks(n, ids);
+    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
 {
-    d_4_0_Core->DeleteTransformFeedbacks(n, ids);
+    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBindTransformFeedback(GLenum target, GLuint id)
 {
-    d_4_0_Core->BindTransformFeedback(target, id);
+    d_4_0_Core->f.BindTransformFeedback(target, id);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPatchParameterfv(GLenum pname, const GLfloat *values)
 {
-    d_4_0_Core->PatchParameterfv(pname, values);
+    d_4_0_Core->f.PatchParameterfv(pname, values);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPatchParameteri(GLenum pname, GLint value)
 {
-    d_4_0_Core->PatchParameteri(pname, value);
+    d_4_0_Core->f.PatchParameteri(pname, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetProgramStageiv(program, shadertype, pname, values);
+    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
 {
-    d_4_0_Core->GetUniformSubroutineuiv(shadertype, location, params);
+    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
 {
-    d_4_0_Core->UniformSubroutinesuiv(shadertype, count, indices);
+    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
+    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
 }
 
 inline GLuint QOpenGLFunctions_4_3_Compatibility::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineIndex(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
 }
 
 inline GLint QOpenGLFunctions_4_3_Compatibility::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineUniformLocation(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
 {
-    d_4_0_Core->GetUniformdv(program, location, params);
+    d_4_0_Core->f.GetUniformdv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform4dv(location, count, value);
+    d_4_0_Core->f.Uniform4dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform3dv(location, count, value);
+    d_4_0_Core->f.Uniform3dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform2dv(location, count, value);
+    d_4_0_Core->f.Uniform2dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform1dv(location, count, value);
+    d_4_0_Core->f.Uniform1dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_0_Core->Uniform4d(location, x, y, z, w);
+    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_0_Core->Uniform3d(location, x, y, z);
+    d_4_0_Core->f.Uniform3d(location, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform2d(GLint location, GLdouble x, GLdouble y)
 {
-    d_4_0_Core->Uniform2d(location, x, y);
+    d_4_0_Core->f.Uniform2d(location, x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUniform1d(GLint location, GLdouble x)
 {
-    d_4_0_Core->Uniform1d(location, x);
+    d_4_0_Core->f.Uniform1d(location, x);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
 {
-    d_4_0_Core->DrawElementsIndirect(mode, type, indirect);
+    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawArraysIndirect(GLenum mode, const GLvoid *indirect)
 {
-    d_4_0_Core->DrawArraysIndirect(mode, indirect);
+    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-    d_4_0_Core->BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
 {
-    d_4_0_Core->BlendFunci(buf, src, dst);
+    d_4_0_Core->f.BlendFunci(buf, src, dst);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
 {
-    d_4_0_Core->BlendEquationSeparatei(buf, modeRGB, modeAlpha);
+    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBlendEquationi(GLuint buf, GLenum mode)
 {
-    d_4_0_Core->BlendEquationi(buf, mode);
+    d_4_0_Core->f.BlendEquationi(buf, mode);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMinSampleShading(GLfloat value)
 {
-    d_4_0_Core->MinSampleShading(value);
+    d_4_0_Core->f.MinSampleShading(value);
 }
 
 
 // OpenGL 4.1 core functions
 inline void QOpenGLFunctions_4_3_Compatibility::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
 {
-    d_4_1_Core->GetDoublei_v(target, index, data);
+    d_4_1_Core->f.GetDoublei_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
 {
-    d_4_1_Core->GetFloati_v(target, index, data);
+    d_4_1_Core->f.GetFloati_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
 {
-    d_4_1_Core->DepthRangeIndexed(index, n, f);
+    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
 {
-    d_4_1_Core->DepthRangeArrayv(first, count, v);
+    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glScissorIndexedv(GLuint index, const GLint *v)
 {
-    d_4_1_Core->ScissorIndexedv(index, v);
+    d_4_1_Core->f.ScissorIndexedv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
 {
-    d_4_1_Core->ScissorIndexed(index, left, bottom, width, height);
+    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
 {
-    d_4_1_Core->ScissorArrayv(first, count, v);
+    d_4_1_Core->f.ScissorArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glViewportIndexedfv(GLuint index, const GLfloat *v)
 {
-    d_4_1_Core->ViewportIndexedfv(index, v);
+    d_4_1_Core->f.ViewportIndexedfv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
 {
-    d_4_1_Core->ViewportIndexedf(index, x, y, w, h);
+    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
 {
-    d_4_1_Core->ViewportArrayv(first, count, v);
+    d_4_1_Core->f.ViewportArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_4_1_Core->GetVertexAttribLdv(index, pname, params);
+    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_4_1_Core->VertexAttribLPointer(index, size, type, stride, pointer);
+    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribL4dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL4dv(index, v);
+    d_4_1_Core->f.VertexAttribL4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribL3dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL3dv(index, v);
+    d_4_1_Core->f.VertexAttribL3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribL2dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL2dv(index, v);
+    d_4_1_Core->f.VertexAttribL2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribL1dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL1dv(index, v);
+    d_4_1_Core->f.VertexAttribL1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_1_Core->VertexAttribL4d(index, x, y, z, w);
+    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_1_Core->VertexAttribL3d(index, x, y, z);
+    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_4_1_Core->VertexAttribL2d(index, x, y);
+    d_4_1_Core->f.VertexAttribL2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribL1d(GLuint index, GLdouble x)
 {
-    d_4_1_Core->VertexAttribL1d(index, x);
+    d_4_1_Core->f.VertexAttribL1d(index, x);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_4_1_Core->GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glValidateProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->ValidateProgramPipeline(pipeline);
+    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform4uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_4_1_Core->ProgramUniform4ui(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform4dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
 {
-    d_4_1_Core->ProgramUniform4d(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform4fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_4_1_Core->ProgramUniform4f(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform4iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_4_1_Core->ProgramUniform4i(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform3uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_4_1_Core->ProgramUniform3ui(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform3dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
 {
-    d_4_1_Core->ProgramUniform3d(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform3fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_4_1_Core->ProgramUniform3f(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform3iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_4_1_Core->ProgramUniform3i(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform2uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
 {
-    d_4_1_Core->ProgramUniform2ui(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform2dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
 {
-    d_4_1_Core->ProgramUniform2d(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform2fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
 {
-    d_4_1_Core->ProgramUniform2f(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform2iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
 {
-    d_4_1_Core->ProgramUniform2i(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform1uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
 {
-    d_4_1_Core->ProgramUniform1ui(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform1dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
 {
-    d_4_1_Core->ProgramUniform1d(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform1fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
 {
-    d_4_1_Core->ProgramUniform1f(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform1iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramUniform1i(GLuint program, GLint location, GLint v0)
 {
-    d_4_1_Core->ProgramUniform1i(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
 {
-    d_4_1_Core->GetProgramPipelineiv(pipeline, pname, params);
+    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsProgramPipeline(GLuint pipeline)
 {
-    return d_4_1_Core->IsProgramPipeline(pipeline);
+    return d_4_1_Core->f.IsProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
 {
-    d_4_1_Core->GenProgramPipelines(n, pipelines);
+    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
 {
-    d_4_1_Core->DeleteProgramPipelines(n, pipelines);
+    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBindProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->BindProgramPipeline(pipeline);
+    d_4_1_Core->f.BindProgramPipeline(pipeline);
 }
 
 inline GLuint QOpenGLFunctions_4_3_Compatibility::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings)
 {
-    return d_4_1_Core->CreateShaderProgramv(type, count, strings);
+    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glActiveShaderProgram(GLuint pipeline, GLuint program)
 {
-    d_4_1_Core->ActiveShaderProgram(pipeline, program);
+    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
 {
-    d_4_1_Core->UseProgramStages(pipeline, stages, program);
+    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramParameteri(GLuint program, GLenum pname, GLint value)
 {
-    d_4_1_Core->ProgramParameteri(program, pname, value);
+    d_4_1_Core->f.ProgramParameteri(program, pname, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length)
 {
-    d_4_1_Core->ProgramBinary(program, binaryFormat, binary, length);
+    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
 {
-    d_4_1_Core->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
+    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glClearDepthf(GLfloat dd)
 {
-    d_4_1_Core->ClearDepthf(dd);
+    d_4_1_Core->f.ClearDepthf(dd);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDepthRangef(GLfloat n, GLfloat f)
 {
-    d_4_1_Core->DepthRangef(n, f);
+    d_4_1_Core->f.DepthRangef(n, f);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
 {
-    d_4_1_Core->GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length)
 {
-    d_4_1_Core->ShaderBinary(count, shaders, binaryformat, binary, length);
+    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glReleaseShaderCompiler()
 {
-    d_4_1_Core->ReleaseShaderCompiler();
+    d_4_1_Core->f.ReleaseShaderCompiler();
 }
 
 
 // OpenGL 4.2 core functions
 inline void QOpenGLFunctions_4_3_Compatibility::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
-    d_4_2_Core->TexStorage3D(target, levels, internalformat, width, height, depth);
+    d_4_2_Core->f.TexStorage3D(target, levels, internalformat, width, height, depth);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_4_2_Core->TexStorage2D(target, levels, internalformat, width, height);
+    d_4_2_Core->f.TexStorage2D(target, levels, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
 {
-    d_4_2_Core->TexStorage1D(target, levels, internalformat, width);
+    d_4_2_Core->f.TexStorage1D(target, levels, internalformat, width);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMemoryBarrier(GLbitfield barriers)
 {
-    d_4_2_Core->MemoryBarrier(barriers);
+    d_4_2_Core->f.MemoryBarrier(barriers);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
 {
-    d_4_2_Core->BindImageTexture(unit, texture, level, layered, layer, access, format);
+    d_4_2_Core->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
 {
-    d_4_2_Core->GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
+    d_4_2_Core->f.GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
 {
-    d_4_2_Core->GetInternalformativ(target, internalformat, pname, bufSize, params);
+    d_4_2_Core->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
 {
-    d_4_2_Core->DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
+    d_4_2_Core->f.DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
 {
-    d_4_2_Core->DrawTransformFeedbackInstanced(mode, id, instancecount);
+    d_4_2_Core->f.DrawTransformFeedbackInstanced(mode, id, instancecount);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
 {
-    d_4_2_Core->DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
+    d_4_2_Core->f.DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
 {
-    d_4_2_Core->DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
+    d_4_2_Core->f.DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
 {
-    d_4_2_Core->DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
+    d_4_2_Core->f.DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
 }
 
 
 // OpenGL 4.3 core functions
 inline void QOpenGLFunctions_4_3_Compatibility::glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_4_3_Core->TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_4_3_Core->f.TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_4_3_Core->TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_4_3_Core->f.TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_4_3_Core->TexBufferRange(target, internalformat, buffer, offset, size);
+    d_4_3_Core->f.TexBufferRange(target, internalformat, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
 {
-    d_4_3_Core->ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
+    d_4_3_Core->f.ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
 }
 
 inline GLint QOpenGLFunctions_4_3_Compatibility::glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceLocationIndex(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceLocationIndex(program, programInterface, name);
 }
 
 inline GLint QOpenGLFunctions_4_3_Compatibility::glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceLocation(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceLocation(program, programInterface, name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
 {
-    d_4_3_Core->GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
+    d_4_3_Core->f.GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
 {
-    d_4_3_Core->GetProgramResourceName(program, programInterface, index, bufSize, length, name);
+    d_4_3_Core->f.GetProgramResourceName(program, programInterface, index, bufSize, length, name);
 }
 
 inline GLuint QOpenGLFunctions_4_3_Compatibility::glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceIndex(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceIndex(program, programInterface, name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params)
 {
-    d_4_3_Core->GetProgramInterfaceiv(program, programInterface, pname, params);
+    d_4_3_Core->f.GetProgramInterfaceiv(program, programInterface, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
 {
-    d_4_3_Core->MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
+    d_4_3_Core->f.MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
 {
-    d_4_3_Core->MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
+    d_4_3_Core->f.MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_4_3_Core->InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
+    d_4_3_Core->f.InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
 {
-    d_4_3_Core->InvalidateFramebuffer(target, numAttachments, attachments);
+    d_4_3_Core->f.InvalidateFramebuffer(target, numAttachments, attachments);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glInvalidateBufferData(GLuint buffer)
 {
-    d_4_3_Core->InvalidateBufferData(buffer);
+    d_4_3_Core->f.InvalidateBufferData(buffer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
 {
-    d_4_3_Core->InvalidateBufferSubData(buffer, offset, length);
+    d_4_3_Core->f.InvalidateBufferSubData(buffer, offset, length);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glInvalidateTexImage(GLuint texture, GLint level)
 {
-    d_4_3_Core->InvalidateTexImage(texture, level);
+    d_4_3_Core->f.InvalidateTexImage(texture, level);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
 {
-    d_4_3_Core->InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
+    d_4_3_Core->f.InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)
 {
-    d_4_3_Core->GetInternalformati64v(target, internalformat, pname, bufSize, params);
+    d_4_3_Core->f.GetInternalformati64v(target, internalformat, pname, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_4_3_Core->GetFramebufferParameteriv(target, pname, params);
+    d_4_3_Core->f.GetFramebufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_4_3_Core->FramebufferParameteri(target, pname, param);
+    d_4_3_Core->f.FramebufferParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
 {
-    d_4_3_Core->VertexBindingDivisor(bindingindex, divisor);
+    d_4_3_Core->f.VertexBindingDivisor(bindingindex, divisor);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
 {
-    d_4_3_Core->VertexAttribBinding(attribindex, bindingindex);
+    d_4_3_Core->f.VertexAttribBinding(attribindex, bindingindex);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribLFormat(attribindex, size, type, relativeoffset);
+    d_4_3_Core->f.VertexAttribLFormat(attribindex, size, type, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribIFormat(attribindex, size, type, relativeoffset);
+    d_4_3_Core->f.VertexAttribIFormat(attribindex, size, type, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
+    d_4_3_Core->f.VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
 {
-    d_4_3_Core->BindVertexBuffer(bindingindex, buffer, offset, stride);
+    d_4_3_Core->f.BindVertexBuffer(bindingindex, buffer, offset, stride);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
 {
-    d_4_3_Core->TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
+    d_4_3_Core->f.TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
 {
-    d_4_3_Core->CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
+    d_4_3_Core->f.CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDispatchComputeIndirect(GLintptr indirect)
 {
-    d_4_3_Core->DispatchComputeIndirect(indirect);
+    d_4_3_Core->f.DispatchComputeIndirect(indirect);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
 {
-    d_4_3_Core->DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
+    d_4_3_Core->f.DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
 {
-    d_4_3_Core->ClearBufferSubData(target, internalformat, offset, size, format, type, data);
+    d_4_3_Core->f.ClearBufferSubData(target, internalformat, offset, size, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)
 {
-    d_4_3_Core->ClearBufferData(target, internalformat, format, type, data);
+    d_4_3_Core->f.ClearBufferData(target, internalformat, format, type, data);
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_4_3_Compatibility::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPixelMapusv(GLenum map, GLint mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPixelMapuiv(GLenum map, GLint mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPixelMapfv(GLenum map, GLint mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_4_3_Compatibility::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_4_3_Compatibility::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
 // OpenGL 1.1 deprecated functions
 inline void QOpenGLFunctions_4_3_Compatibility::glPushClientAttrib(GLbitfield mask)
 {
-    d_1_1_Deprecated->PushClientAttrib(mask);
+    d_1_1_Deprecated->f.PushClientAttrib(mask);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPopClientAttrib()
 {
-    d_1_1_Deprecated->PopClientAttrib();
+    d_1_1_Deprecated->f.PopClientAttrib();
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 {
-    d_1_1_Deprecated->PrioritizeTextures(n, textures, priorities);
+    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Compatibility::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-    return d_1_1_Deprecated->AreTexturesResident(n, textures, residences);
+    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->VertexPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->TexCoordPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->NormalPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->InterleavedArrays(format, stride, pointer);
+    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->IndexPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEnableClientState(GLenum array)
 {
-    d_1_1_Deprecated->EnableClientState(array);
+    d_1_1_Deprecated->f.EnableClientState(array);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->EdgeFlagPointer(stride, pointer);
+    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glDisableClientState(GLenum array)
 {
-    d_1_1_Deprecated->DisableClientState(array);
+    d_1_1_Deprecated->f.DisableClientState(array);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_1_Deprecated->ColorPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glArrayElement(GLint i)
 {
-    d_1_1_Deprecated->ArrayElement(i);
+    d_1_1_Deprecated->f.ArrayElement(i);
 }
 
 
 // OpenGL 1.2 deprecated functions
 inline void QOpenGLFunctions_4_3_Compatibility::glResetMinmax(GLenum target)
 {
-    d_1_2_Deprecated->ResetMinmax(target);
+    d_1_2_Deprecated->f.ResetMinmax(target);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glResetHistogram(GLenum target)
 {
-    d_1_2_Deprecated->ResetHistogram(target);
+    d_1_2_Deprecated->f.ResetHistogram(target);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Minmax(target, internalformat, sink);
+    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Histogram(target, width, internalformat, sink);
+    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetMinmax(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetHistogramParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetHistogramParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)
 {
-    d_1_2_Deprecated->GetHistogram(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)
 {
-    d_1_2_Deprecated->SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
+    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)
 {
-    d_1_2_Deprecated->GetSeparableFilter(target, format, type, row, column, span);
+    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, GLvoid *image)
 {
-    d_1_2_Deprecated->GetConvolutionFilter(target, format, type, image);
+    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
+    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter1D(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
 {
-    d_1_2_Deprecated->ConvolutionParameteri(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
 {
-    d_1_2_Deprecated->ConvolutionParameterf(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter1D(target, internalformat, width, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorSubTable(target, start, x, y, width);
+    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)
 {
-    d_1_2_Deprecated->ColorSubTable(target, start, count, format, type, data);
+    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glGetColorTable(GLenum target, GLenum format, GLenum type, GLvoid *table)
 {
-    d_1_2_Deprecated->GetColorTable(target, format, type, table);
+    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorTable(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)
 {
-    d_1_2_Deprecated->ColorTable(target, internalformat, width, format, type, table);
+    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
 }
 
 
 // OpenGL 1.3 deprecated functions
 inline void QOpenGLFunctions_4_3_Compatibility::glMultTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixd(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixf(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLoadTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixd(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glLoadTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixf(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord4sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_3_Deprecated->MultiTexCoord4s(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord4iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_3_Deprecated->MultiTexCoord4i(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_3_Deprecated->MultiTexCoord4f(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_3_Deprecated->MultiTexCoord4d(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord3sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
 {
-    d_1_3_Deprecated->MultiTexCoord3s(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord3iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
 {
-    d_1_3_Deprecated->MultiTexCoord3i(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_3_Deprecated->MultiTexCoord3f(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_3_Deprecated->MultiTexCoord3d(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord2sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
 {
-    d_1_3_Deprecated->MultiTexCoord2s(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord2iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
 {
-    d_1_3_Deprecated->MultiTexCoord2i(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
 {
-    d_1_3_Deprecated->MultiTexCoord2f(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
 {
-    d_1_3_Deprecated->MultiTexCoord2d(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord1sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord1s(GLenum target, GLshort s)
 {
-    d_1_3_Deprecated->MultiTexCoord1s(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord1iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord1i(GLenum target, GLint s)
 {
-    d_1_3_Deprecated->MultiTexCoord1i(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord1f(GLenum target, GLfloat s)
 {
-    d_1_3_Deprecated->MultiTexCoord1f(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glMultiTexCoord1d(GLenum target, GLdouble s)
 {
-    d_1_3_Deprecated->MultiTexCoord1d(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glClientActiveTexture(GLenum texture)
 {
-    d_1_3_Deprecated->ClientActiveTexture(texture);
+    d_1_3_Deprecated->f.ClientActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 deprecated functions
 inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos3sv(v);
+    d_1_4_Deprecated->f.WindowPos3sv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_4_Deprecated->WindowPos3s(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos3iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos3iv(v);
+    d_1_4_Deprecated->f.WindowPos3iv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_4_Deprecated->WindowPos3i(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos3fv(v);
+    d_1_4_Deprecated->f.WindowPos3fv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_4_Deprecated->WindowPos3f(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos3dv(v);
+    d_1_4_Deprecated->f.WindowPos3dv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_4_Deprecated->WindowPos3d(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos2sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos2sv(v);
+    d_1_4_Deprecated->f.WindowPos2sv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos2s(GLshort x, GLshort y)
 {
-    d_1_4_Deprecated->WindowPos2s(x, y);
+    d_1_4_Deprecated->f.WindowPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos2iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos2iv(v);
+    d_1_4_Deprecated->f.WindowPos2iv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos2i(GLint x, GLint y)
 {
-    d_1_4_Deprecated->WindowPos2i(x, y);
+    d_1_4_Deprecated->f.WindowPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos2fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos2fv(v);
+    d_1_4_Deprecated->f.WindowPos2fv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos2f(GLfloat x, GLfloat y)
 {
-    d_1_4_Deprecated->WindowPos2f(x, y);
+    d_1_4_Deprecated->f.WindowPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos2dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos2dv(v);
+    d_1_4_Deprecated->f.WindowPos2dv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glWindowPos2d(GLdouble x, GLdouble y)
 {
-    d_1_4_Deprecated->WindowPos2d(x, y);
+    d_1_4_Deprecated->f.WindowPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->SecondaryColorPointer(size, type, stride, pointer);
+    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3usv(const GLushort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3usv(v);
+    d_1_4_Deprecated->f.SecondaryColor3usv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3us(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3uiv(const GLuint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3uiv(v);
+    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ui(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3ubv(const GLubyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3ubv(v);
+    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ub(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3sv(v);
+    d_1_4_Deprecated->f.SecondaryColor3sv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3s(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3iv(const GLint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3iv(v);
+    d_1_4_Deprecated->f.SecondaryColor3iv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3i(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->SecondaryColor3fv(v);
+    d_1_4_Deprecated->f.SecondaryColor3fv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_4_Deprecated->SecondaryColor3f(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->SecondaryColor3dv(v);
+    d_1_4_Deprecated->f.SecondaryColor3dv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_4_Deprecated->SecondaryColor3d(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3bv(const GLbyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3bv(v);
+    d_1_4_Deprecated->f.SecondaryColor3bv(v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3b(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFogCoordPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_1_4_Deprecated->FogCoordPointer(type, stride, pointer);
+    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFogCoorddv(const GLdouble *coord)
 {
-    d_1_4_Deprecated->FogCoorddv(coord);
+    d_1_4_Deprecated->f.FogCoorddv(coord);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFogCoordd(GLdouble coord)
 {
-    d_1_4_Deprecated->FogCoordd(coord);
+    d_1_4_Deprecated->f.FogCoordd(coord);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFogCoordfv(const GLfloat *coord)
 {
-    d_1_4_Deprecated->FogCoordfv(coord);
+    d_1_4_Deprecated->f.FogCoordfv(coord);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glFogCoordf(GLfloat coord)
 {
-    d_1_4_Deprecated->FogCoordf(coord);
+    d_1_4_Deprecated->f.FogCoordf(coord);
 }
 
 
@@ -5538,182 +5539,182 @@ inline void QOpenGLFunctions_4_3_Compatibility::glFogCoordf(GLfloat coord)
 // OpenGL 2.0 deprecated functions
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4usv(index, v);
+    d_2_0_Core->f.VertexAttrib4usv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4uiv(index, v);
+    d_2_0_Core->f.VertexAttrib4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4ubv(index, v);
+    d_2_0_Core->f.VertexAttrib4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4sv(index, v);
+    d_2_0_Core->f.VertexAttrib4sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4iv(index, v);
+    d_2_0_Core->f.VertexAttrib4iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib4fv(index, v);
+    d_2_0_Core->f.VertexAttrib4fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib4dv(index, v);
+    d_2_0_Core->f.VertexAttrib4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4bv(index, v);
+    d_2_0_Core->f.VertexAttrib4bv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4Nusv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4Nuiv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nubv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
 {
-    d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4Nsv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4Niv(index, v);
+    d_2_0_Core->f.VertexAttrib4Niv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nbv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib3sv(index, v);
+    d_2_0_Core->f.VertexAttrib3sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
 {
-    d_2_0_Core->VertexAttrib3s(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib3fv(index, v);
+    d_2_0_Core->f.VertexAttrib3fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_2_0_Core->VertexAttrib3f(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib3dv(index, v);
+    d_2_0_Core->f.VertexAttrib3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_2_0_Core->VertexAttrib3d(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib2sv(index, v);
+    d_2_0_Core->f.VertexAttrib2sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
 {
-    d_2_0_Core->VertexAttrib2s(index, x, y);
+    d_2_0_Core->f.VertexAttrib2s(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib2fv(index, v);
+    d_2_0_Core->f.VertexAttrib2fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
 {
-    d_2_0_Core->VertexAttrib2f(index, x, y);
+    d_2_0_Core->f.VertexAttrib2f(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib2dv(index, v);
+    d_2_0_Core->f.VertexAttrib2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_2_0_Core->VertexAttrib2d(index, x, y);
+    d_2_0_Core->f.VertexAttrib2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib1sv(index, v);
+    d_2_0_Core->f.VertexAttrib1sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
 {
-    d_2_0_Core->VertexAttrib1s(index, x);
+    d_2_0_Core->f.VertexAttrib1s(index, x);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib1fv(index, v);
+    d_2_0_Core->f.VertexAttrib1fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
 {
-    d_2_0_Core->VertexAttrib1f(index, x);
+    d_2_0_Core->f.VertexAttrib1f(index, x);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib1dv(index, v);
+    d_2_0_Core->f.VertexAttrib1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
 {
-    d_2_0_Core->VertexAttrib1d(index, x);
+    d_2_0_Core->f.VertexAttrib1d(index, x);
 }
 
 
@@ -5722,102 +5723,102 @@ inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttrib1d(GLuint index, G
 // OpenGL 3.0 deprecated functions
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
 {
-    d_3_0_Core->VertexAttribI4usv(index, v);
+    d_3_0_Core->f.VertexAttribI4usv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
 {
-    d_3_0_Core->VertexAttribI4ubv(index, v);
+    d_3_0_Core->f.VertexAttribI4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
 {
-    d_3_0_Core->VertexAttribI4sv(index, v);
+    d_3_0_Core->f.VertexAttribI4sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
 {
-    d_3_0_Core->VertexAttribI4bv(index, v);
+    d_3_0_Core->f.VertexAttribI4bv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI4uiv(index, v);
+    d_3_0_Core->f.VertexAttribI4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI3uiv(index, v);
+    d_3_0_Core->f.VertexAttribI3uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI2uiv(index, v);
+    d_3_0_Core->f.VertexAttribI2uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI1uiv(index, v);
+    d_3_0_Core->f.VertexAttribI1uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI4iv(index, v);
+    d_3_0_Core->f.VertexAttribI4iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI3iv(index, v);
+    d_3_0_Core->f.VertexAttribI3iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI2iv(index, v);
+    d_3_0_Core->f.VertexAttribI2iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI1iv(index, v);
+    d_3_0_Core->f.VertexAttribI1iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
 {
-    d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
 {
-    d_3_0_Core->VertexAttribI3ui(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
 {
-    d_3_0_Core->VertexAttribI2ui(index, x, y);
+    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
 {
-    d_3_0_Core->VertexAttribI1ui(index, x);
+    d_3_0_Core->f.VertexAttribI1ui(index, x);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
 {
-    d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
 {
-    d_3_0_Core->VertexAttribI3i(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
 {
-    d_3_0_Core->VertexAttribI2i(index, x, y);
+    d_3_0_Core->f.VertexAttribI2i(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
 {
-    d_3_0_Core->VertexAttribI1i(index, x);
+    d_3_0_Core->f.VertexAttribI1i(index, x);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_4_3_core.cpp b/src/gui/opengl/qopenglfunctions_4_3_core.cpp
index 5d8bb179ce5..d3f988ba0de 100644
--- a/src/gui/opengl/qopenglfunctions_4_3_core.cpp
+++ b/src/gui/opengl/qopenglfunctions_4_3_core.cpp
@@ -88,70 +88,54 @@ QOpenGLFunctions_4_3_Core::QOpenGLFunctions_4_3_Core()
 
 QOpenGLFunctions_4_3_Core::~QOpenGLFunctions_4_3_Core()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
-    if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        delete d_3_2_Core;
-    }
-    if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        delete d_3_3_Core;
-    }
-    if (d_4_0_Core && !d_4_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_0_Core->context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        delete d_4_0_Core;
-    }
-    if (d_4_1_Core && !d_4_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_1_Core->context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        delete d_4_1_Core;
-    }
-    if (d_4_2_Core && !d_4_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_2_Core->context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        delete d_4_2_Core;
-    }
-    if (d_4_3_Core && !d_4_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_3_Core->context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        delete d_4_3_Core;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
+    if (d_3_2_Core)
+        d_3_2_Core->refs.deref();
+    Q_ASSERT(d_3_2_Core->refs.load());
+    if (d_3_3_Core)
+        d_3_3_Core->refs.deref();
+    Q_ASSERT(d_3_3_Core->refs.load());
+    if (d_4_0_Core)
+        d_4_0_Core->refs.deref();
+    Q_ASSERT(d_4_0_Core->refs.load());
+    if (d_4_1_Core)
+        d_4_1_Core->refs.deref();
+    Q_ASSERT(d_4_1_Core->refs.load());
+    if (d_4_2_Core)
+        d_4_2_Core->refs.deref();
+    Q_ASSERT(d_4_2_Core->refs.load());
+    if (d_4_3_Core)
+        d_4_3_Core->refs.deref();
+    Q_ASSERT(d_4_3_Core->refs.load());
 }
 
 bool QOpenGLFunctions_4_3_Core::initializeOpenGLFunctions()
@@ -170,130 +154,66 @@ bool QOpenGLFunctions_4_3_Core::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
-        }
         d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
-        }
         d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus(), d);
-        }
         d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus(), d);
-        }
         d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus(), d);
-        }
         d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus(), d);
-        }
         d_4_3_Core = static_cast<QOpenGLFunctions_4_3_CoreBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_4_3_core.h b/src/gui/opengl/qopenglfunctions_4_3_core.h
index fab5fcd9f28..7e18292bb0c 100644
--- a/src/gui/opengl/qopenglfunctions_4_3_core.h
+++ b/src/gui/opengl/qopenglfunctions_4_3_core.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -625,242 +626,242 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_4_3_Core::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Core::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_3_Core::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetIntegerv(GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetIntegerv(pname, params);
+    d_1_0_Core->f.GetIntegerv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetFloatv(GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetFloatv(pname, params);
+    d_1_0_Core->f.GetFloatv(pname, params);
 }
 
 inline GLenum QOpenGLFunctions_4_3_Core::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetDoublev(GLenum pname, GLdouble *params)
 {
-    d_1_0_Core->GetDoublev(pname, params);
+    d_1_0_Core->f.GetDoublev(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetBooleanv(GLenum pname, GLboolean *params)
 {
-    d_1_0_Core->GetBooleanv(pname, params);
+    d_1_0_Core->f.GetBooleanv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glReadBuffer(GLenum mode)
 {
-    d_1_0_Core->ReadBuffer(mode);
+    d_1_0_Core->f.ReadBuffer(mode);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_4_3_Core::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_4_3_Core::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawBuffer(GLenum mode)
 {
-    d_1_0_Core->DrawBuffer(mode);
+    d_1_0_Core->f.DrawBuffer(mode);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
@@ -879,57 +880,57 @@ inline void QOpenGLFunctions_4_3_Core::glIndexub(GLubyte c)
 
 inline GLboolean QOpenGLFunctions_4_3_Core::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetPointerv(GLenum pname, GLvoid* *params)
@@ -941,1067 +942,1067 @@ inline void QOpenGLFunctions_4_3_Core::glGetPointerv(GLenum pname, GLvoid* *para
 
 inline void QOpenGLFunctions_4_3_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_4_3_Core::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_4_3_Core::glGetCompressedTexImage(GLenum target, GLint level, GLvoid *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_4_3_Core::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_4_3_Core::glGetBufferPointerv(GLenum target, GLenum pname, GLvoid* *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Core::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline GLvoid* QOpenGLFunctions_4_3_Core::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Core::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Core::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glShaderSource(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Core::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Core::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetVertexAttribPointerv(GLuint index, GLenum pname, GLvoid* *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_4_3_Core::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_4_3_Core::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *obj)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, obj);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, obj);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_4_3_Core::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_4_3_Core::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_4_3_Core::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_4_3_Core::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline GLvoid* QOpenGLFunctions_4_3_Core::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_4_3_Core::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Core::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Core::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_3_Core::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_4_3_Core::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Core::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_4_3_Core::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_4_3_Core::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
 // OpenGL 3.2 core functions
 inline void QOpenGLFunctions_4_3_Core::glSampleMaski(GLuint index, GLbitfield mask)
 {
-    d_3_2_Core->SampleMaski(index, mask);
+    d_3_2_Core->f.SampleMaski(index, mask);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
 {
-    d_3_2_Core->GetMultisamplefv(pname, index, val);
+    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexImage3DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexImage2DMultisample(GLenum target, GLsizei samples, GLint internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
-    d_3_2_Core->GetSynciv(sync, pname, bufSize, length, values);
+    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetInteger64v(GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetInteger64v(pname, params);
+    d_3_2_Core->f.GetInteger64v(pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    d_3_2_Core->WaitSync(sync, flags, timeout);
+    d_3_2_Core->f.WaitSync(sync, flags, timeout);
 }
 
 inline GLenum QOpenGLFunctions_4_3_Core::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    return d_3_2_Core->ClientWaitSync(sync, flags, timeout);
+    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDeleteSync(GLsync sync)
 {
-    d_3_2_Core->DeleteSync(sync);
+    d_3_2_Core->f.DeleteSync(sync);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Core::glIsSync(GLsync sync)
 {
-    return d_3_2_Core->IsSync(sync);
+    return d_3_2_Core->f.IsSync(sync);
 }
 
 inline GLsync QOpenGLFunctions_4_3_Core::glFenceSync(GLenum condition, GLbitfield flags)
 {
-    return d_3_2_Core->FenceSync(condition, flags);
+    return d_3_2_Core->f.FenceSync(condition, flags);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProvokingVertex(GLenum mode)
 {
-    d_3_2_Core->ProvokingVertex(mode);
+    d_3_2_Core->f.ProvokingVertex(mode);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)
 {
-    d_3_2_Core->MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
-    d_3_2_Core->FramebufferTexture(target, attachment, texture, level);
+    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetBufferParameteri64v(target, pname, params);
+    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64i_v(target, index, data);
+    d_3_2_Core->f.GetInteger64i_v(target, index, data);
 }
 
 
 // OpenGL 3.3 core functions
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP4uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP4ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP3uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP3ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP2uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP2ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP1uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP1ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
@@ -2224,1005 +2225,1005 @@ inline void QOpenGLFunctions_4_3_Core::glVertexP2ui(GLenum type, GLuint value)
 
 inline void QOpenGLFunctions_4_3_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
 {
-    d_3_3_Core->GetQueryObjectui64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
 {
-    d_3_3_Core->GetQueryObjecti64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glQueryCounter(GLuint id, GLenum target)
 {
-    d_3_3_Core->QueryCounter(id, target);
+    d_3_3_Core->f.QueryCounter(id, target);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
 {
-    d_3_3_Core->GetSamplerParameterIuiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
 {
-    d_3_3_Core->GetSamplerParameterfv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameterIiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameteriv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
 {
-    d_3_3_Core->SamplerParameterIuiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameterIiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
 {
-    d_3_3_Core->SamplerParameterfv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
 {
-    d_3_3_Core->SamplerParameterf(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameteriv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
-    d_3_3_Core->SamplerParameteri(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBindSampler(GLuint unit, GLuint sampler)
 {
-    d_3_3_Core->BindSampler(unit, sampler);
+    d_3_3_Core->f.BindSampler(unit, sampler);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Core::glIsSampler(GLuint sampler)
 {
-    return d_3_3_Core->IsSampler(sampler);
+    return d_3_3_Core->f.IsSampler(sampler);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDeleteSamplers(GLsizei count, const GLuint *samplers)
 {
-    d_3_3_Core->DeleteSamplers(count, samplers);
+    d_3_3_Core->f.DeleteSamplers(count, samplers);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGenSamplers(GLsizei count, GLuint *samplers)
 {
-    d_3_3_Core->GenSamplers(count, samplers);
+    d_3_3_Core->f.GenSamplers(count, samplers);
 }
 
 inline GLint QOpenGLFunctions_4_3_Core::glGetFragDataIndex(GLuint program, const GLchar *name)
 {
-    return d_3_3_Core->GetFragDataIndex(program, name);
+    return d_3_3_Core->f.GetFragDataIndex(program, name);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
 {
-    d_3_3_Core->BindFragDataLocationIndexed(program, colorNumber, index, name);
+    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribDivisor(GLuint index, GLuint divisor)
 {
-    d_3_3_Core->VertexAttribDivisor(index, divisor);
+    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
 }
 
 
 // OpenGL 4.0 core functions
 inline void QOpenGLFunctions_4_3_Core::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
 {
-    d_4_0_Core->GetQueryIndexediv(target, index, pname, params);
+    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glEndQueryIndexed(GLenum target, GLuint index)
 {
-    d_4_0_Core->EndQueryIndexed(target, index);
+    d_4_0_Core->f.EndQueryIndexed(target, index);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
 {
-    d_4_0_Core->BeginQueryIndexed(target, index, id);
+    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
 {
-    d_4_0_Core->DrawTransformFeedbackStream(mode, id, stream);
+    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawTransformFeedback(GLenum mode, GLuint id)
 {
-    d_4_0_Core->DrawTransformFeedback(mode, id);
+    d_4_0_Core->f.DrawTransformFeedback(mode, id);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glResumeTransformFeedback()
 {
-    d_4_0_Core->ResumeTransformFeedback();
+    d_4_0_Core->f.ResumeTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_3_Core::glPauseTransformFeedback()
 {
-    d_4_0_Core->PauseTransformFeedback();
+    d_4_0_Core->f.PauseTransformFeedback();
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Core::glIsTransformFeedback(GLuint id)
 {
-    return d_4_0_Core->IsTransformFeedback(id);
+    return d_4_0_Core->f.IsTransformFeedback(id);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
 {
-    d_4_0_Core->GenTransformFeedbacks(n, ids);
+    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
 {
-    d_4_0_Core->DeleteTransformFeedbacks(n, ids);
+    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBindTransformFeedback(GLenum target, GLuint id)
 {
-    d_4_0_Core->BindTransformFeedback(target, id);
+    d_4_0_Core->f.BindTransformFeedback(target, id);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glPatchParameterfv(GLenum pname, const GLfloat *values)
 {
-    d_4_0_Core->PatchParameterfv(pname, values);
+    d_4_0_Core->f.PatchParameterfv(pname, values);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glPatchParameteri(GLenum pname, GLint value)
 {
-    d_4_0_Core->PatchParameteri(pname, value);
+    d_4_0_Core->f.PatchParameteri(pname, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetProgramStageiv(program, shadertype, pname, values);
+    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
 {
-    d_4_0_Core->GetUniformSubroutineuiv(shadertype, location, params);
+    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
 {
-    d_4_0_Core->UniformSubroutinesuiv(shadertype, count, indices);
+    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
+    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
 }
 
 inline GLuint QOpenGLFunctions_4_3_Core::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineIndex(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
 }
 
 inline GLint QOpenGLFunctions_4_3_Core::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineUniformLocation(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
 {
-    d_4_0_Core->GetUniformdv(program, location, params);
+    d_4_0_Core->f.GetUniformdv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform4dv(location, count, value);
+    d_4_0_Core->f.Uniform4dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform3dv(location, count, value);
+    d_4_0_Core->f.Uniform3dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform2dv(location, count, value);
+    d_4_0_Core->f.Uniform2dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform1dv(location, count, value);
+    d_4_0_Core->f.Uniform1dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_0_Core->Uniform4d(location, x, y, z, w);
+    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_0_Core->Uniform3d(location, x, y, z);
+    d_4_0_Core->f.Uniform3d(location, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform2d(GLint location, GLdouble x, GLdouble y)
 {
-    d_4_0_Core->Uniform2d(location, x, y);
+    d_4_0_Core->f.Uniform2d(location, x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUniform1d(GLint location, GLdouble x)
 {
-    d_4_0_Core->Uniform1d(location, x);
+    d_4_0_Core->f.Uniform1d(location, x);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawElementsIndirect(GLenum mode, GLenum type, const GLvoid *indirect)
 {
-    d_4_0_Core->DrawElementsIndirect(mode, type, indirect);
+    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawArraysIndirect(GLenum mode, const GLvoid *indirect)
 {
-    d_4_0_Core->DrawArraysIndirect(mode, indirect);
+    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-    d_4_0_Core->BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
 {
-    d_4_0_Core->BlendFunci(buf, src, dst);
+    d_4_0_Core->f.BlendFunci(buf, src, dst);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
 {
-    d_4_0_Core->BlendEquationSeparatei(buf, modeRGB, modeAlpha);
+    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBlendEquationi(GLuint buf, GLenum mode)
 {
-    d_4_0_Core->BlendEquationi(buf, mode);
+    d_4_0_Core->f.BlendEquationi(buf, mode);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glMinSampleShading(GLfloat value)
 {
-    d_4_0_Core->MinSampleShading(value);
+    d_4_0_Core->f.MinSampleShading(value);
 }
 
 
 // OpenGL 4.1 core functions
 inline void QOpenGLFunctions_4_3_Core::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
 {
-    d_4_1_Core->GetDoublei_v(target, index, data);
+    d_4_1_Core->f.GetDoublei_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
 {
-    d_4_1_Core->GetFloati_v(target, index, data);
+    d_4_1_Core->f.GetFloati_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
 {
-    d_4_1_Core->DepthRangeIndexed(index, n, f);
+    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
 {
-    d_4_1_Core->DepthRangeArrayv(first, count, v);
+    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glScissorIndexedv(GLuint index, const GLint *v)
 {
-    d_4_1_Core->ScissorIndexedv(index, v);
+    d_4_1_Core->f.ScissorIndexedv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
 {
-    d_4_1_Core->ScissorIndexed(index, left, bottom, width, height);
+    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
 {
-    d_4_1_Core->ScissorArrayv(first, count, v);
+    d_4_1_Core->f.ScissorArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glViewportIndexedfv(GLuint index, const GLfloat *v)
 {
-    d_4_1_Core->ViewportIndexedfv(index, v);
+    d_4_1_Core->f.ViewportIndexedfv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
 {
-    d_4_1_Core->ViewportIndexedf(index, x, y, w, h);
+    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
 {
-    d_4_1_Core->ViewportArrayv(first, count, v);
+    d_4_1_Core->f.ViewportArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_4_1_Core->GetVertexAttribLdv(index, pname, params);
+    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
 {
-    d_4_1_Core->VertexAttribLPointer(index, size, type, stride, pointer);
+    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribL4dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL4dv(index, v);
+    d_4_1_Core->f.VertexAttribL4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribL3dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL3dv(index, v);
+    d_4_1_Core->f.VertexAttribL3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribL2dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL2dv(index, v);
+    d_4_1_Core->f.VertexAttribL2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribL1dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL1dv(index, v);
+    d_4_1_Core->f.VertexAttribL1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_1_Core->VertexAttribL4d(index, x, y, z, w);
+    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_1_Core->VertexAttribL3d(index, x, y, z);
+    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_4_1_Core->VertexAttribL2d(index, x, y);
+    d_4_1_Core->f.VertexAttribL2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribL1d(GLuint index, GLdouble x)
 {
-    d_4_1_Core->VertexAttribL1d(index, x);
+    d_4_1_Core->f.VertexAttribL1d(index, x);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_4_1_Core->GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glValidateProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->ValidateProgramPipeline(pipeline);
+    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform4uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_4_1_Core->ProgramUniform4ui(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform4dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
 {
-    d_4_1_Core->ProgramUniform4d(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform4fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_4_1_Core->ProgramUniform4f(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform4iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_4_1_Core->ProgramUniform4i(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform3uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_4_1_Core->ProgramUniform3ui(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform3dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
 {
-    d_4_1_Core->ProgramUniform3d(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform3fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_4_1_Core->ProgramUniform3f(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform3iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_4_1_Core->ProgramUniform3i(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform2uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
 {
-    d_4_1_Core->ProgramUniform2ui(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform2dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
 {
-    d_4_1_Core->ProgramUniform2d(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform2fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
 {
-    d_4_1_Core->ProgramUniform2f(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform2iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
 {
-    d_4_1_Core->ProgramUniform2i(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform1uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
 {
-    d_4_1_Core->ProgramUniform1ui(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform1dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
 {
-    d_4_1_Core->ProgramUniform1d(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform1fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
 {
-    d_4_1_Core->ProgramUniform1f(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform1iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramUniform1i(GLuint program, GLint location, GLint v0)
 {
-    d_4_1_Core->ProgramUniform1i(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
 {
-    d_4_1_Core->GetProgramPipelineiv(pipeline, pname, params);
+    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_3_Core::glIsProgramPipeline(GLuint pipeline)
 {
-    return d_4_1_Core->IsProgramPipeline(pipeline);
+    return d_4_1_Core->f.IsProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
 {
-    d_4_1_Core->GenProgramPipelines(n, pipelines);
+    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
 {
-    d_4_1_Core->DeleteProgramPipelines(n, pipelines);
+    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBindProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->BindProgramPipeline(pipeline);
+    d_4_1_Core->f.BindProgramPipeline(pipeline);
 }
 
 inline GLuint QOpenGLFunctions_4_3_Core::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar* const *strings)
 {
-    return d_4_1_Core->CreateShaderProgramv(type, count, strings);
+    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glActiveShaderProgram(GLuint pipeline, GLuint program)
 {
-    d_4_1_Core->ActiveShaderProgram(pipeline, program);
+    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
 {
-    d_4_1_Core->UseProgramStages(pipeline, stages, program);
+    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramParameteri(GLuint program, GLenum pname, GLint value)
 {
-    d_4_1_Core->ProgramParameteri(program, pname, value);
+    d_4_1_Core->f.ProgramParameteri(program, pname, value);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glProgramBinary(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length)
 {
-    d_4_1_Core->ProgramBinary(program, binaryFormat, binary, length);
+    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)
 {
-    d_4_1_Core->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
+    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glClearDepthf(GLfloat dd)
 {
-    d_4_1_Core->ClearDepthf(dd);
+    d_4_1_Core->f.ClearDepthf(dd);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDepthRangef(GLfloat n, GLfloat f)
 {
-    d_4_1_Core->DepthRangef(n, f);
+    d_4_1_Core->f.DepthRangef(n, f);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
 {
-    d_4_1_Core->GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length)
 {
-    d_4_1_Core->ShaderBinary(count, shaders, binaryformat, binary, length);
+    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glReleaseShaderCompiler()
 {
-    d_4_1_Core->ReleaseShaderCompiler();
+    d_4_1_Core->f.ReleaseShaderCompiler();
 }
 
 
 // OpenGL 4.2 core functions
 inline void QOpenGLFunctions_4_3_Core::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
-    d_4_2_Core->TexStorage3D(target, levels, internalformat, width, height, depth);
+    d_4_2_Core->f.TexStorage3D(target, levels, internalformat, width, height, depth);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_4_2_Core->TexStorage2D(target, levels, internalformat, width, height);
+    d_4_2_Core->f.TexStorage2D(target, levels, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
 {
-    d_4_2_Core->TexStorage1D(target, levels, internalformat, width);
+    d_4_2_Core->f.TexStorage1D(target, levels, internalformat, width);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glMemoryBarrier(GLbitfield barriers)
 {
-    d_4_2_Core->MemoryBarrier(barriers);
+    d_4_2_Core->f.MemoryBarrier(barriers);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
 {
-    d_4_2_Core->BindImageTexture(unit, texture, level, layered, layer, access, format);
+    d_4_2_Core->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
 {
-    d_4_2_Core->GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
+    d_4_2_Core->f.GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
 {
-    d_4_2_Core->GetInternalformativ(target, internalformat, pname, bufSize, params);
+    d_4_2_Core->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
 {
-    d_4_2_Core->DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
+    d_4_2_Core->f.DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
 {
-    d_4_2_Core->DrawTransformFeedbackInstanced(mode, id, instancecount);
+    d_4_2_Core->f.DrawTransformFeedbackInstanced(mode, id, instancecount);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
 {
-    d_4_2_Core->DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
+    d_4_2_Core->f.DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
 {
-    d_4_2_Core->DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
+    d_4_2_Core->f.DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
 {
-    d_4_2_Core->DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
+    d_4_2_Core->f.DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
 }
 
 
 // OpenGL 4.3 core functions
 inline void QOpenGLFunctions_4_3_Core::glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_4_3_Core->TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_4_3_Core->f.TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_4_3_Core->TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_4_3_Core->f.TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_4_3_Core->TexBufferRange(target, internalformat, buffer, offset, size);
+    d_4_3_Core->f.TexBufferRange(target, internalformat, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
 {
-    d_4_3_Core->ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
+    d_4_3_Core->f.ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
 }
 
 inline GLint QOpenGLFunctions_4_3_Core::glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceLocationIndex(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceLocationIndex(program, programInterface, name);
 }
 
 inline GLint QOpenGLFunctions_4_3_Core::glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceLocation(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceLocation(program, programInterface, name);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
 {
-    d_4_3_Core->GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
+    d_4_3_Core->f.GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
 {
-    d_4_3_Core->GetProgramResourceName(program, programInterface, index, bufSize, length, name);
+    d_4_3_Core->f.GetProgramResourceName(program, programInterface, index, bufSize, length, name);
 }
 
 inline GLuint QOpenGLFunctions_4_3_Core::glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceIndex(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceIndex(program, programInterface, name);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params)
 {
-    d_4_3_Core->GetProgramInterfaceiv(program, programInterface, pname, params);
+    d_4_3_Core->f.GetProgramInterfaceiv(program, programInterface, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
 {
-    d_4_3_Core->MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
+    d_4_3_Core->f.MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
 {
-    d_4_3_Core->MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
+    d_4_3_Core->f.MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_4_3_Core->InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
+    d_4_3_Core->f.InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
 {
-    d_4_3_Core->InvalidateFramebuffer(target, numAttachments, attachments);
+    d_4_3_Core->f.InvalidateFramebuffer(target, numAttachments, attachments);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glInvalidateBufferData(GLuint buffer)
 {
-    d_4_3_Core->InvalidateBufferData(buffer);
+    d_4_3_Core->f.InvalidateBufferData(buffer);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
 {
-    d_4_3_Core->InvalidateBufferSubData(buffer, offset, length);
+    d_4_3_Core->f.InvalidateBufferSubData(buffer, offset, length);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glInvalidateTexImage(GLuint texture, GLint level)
 {
-    d_4_3_Core->InvalidateTexImage(texture, level);
+    d_4_3_Core->f.InvalidateTexImage(texture, level);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
 {
-    d_4_3_Core->InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
+    d_4_3_Core->f.InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)
 {
-    d_4_3_Core->GetInternalformati64v(target, internalformat, pname, bufSize, params);
+    d_4_3_Core->f.GetInternalformati64v(target, internalformat, pname, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_4_3_Core->GetFramebufferParameteriv(target, pname, params);
+    d_4_3_Core->f.GetFramebufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_4_3_Core->FramebufferParameteri(target, pname, param);
+    d_4_3_Core->f.FramebufferParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
 {
-    d_4_3_Core->VertexBindingDivisor(bindingindex, divisor);
+    d_4_3_Core->f.VertexBindingDivisor(bindingindex, divisor);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
 {
-    d_4_3_Core->VertexAttribBinding(attribindex, bindingindex);
+    d_4_3_Core->f.VertexAttribBinding(attribindex, bindingindex);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribLFormat(attribindex, size, type, relativeoffset);
+    d_4_3_Core->f.VertexAttribLFormat(attribindex, size, type, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribIFormat(attribindex, size, type, relativeoffset);
+    d_4_3_Core->f.VertexAttribIFormat(attribindex, size, type, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
+    d_4_3_Core->f.VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
 {
-    d_4_3_Core->BindVertexBuffer(bindingindex, buffer, offset, stride);
+    d_4_3_Core->f.BindVertexBuffer(bindingindex, buffer, offset, stride);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
 {
-    d_4_3_Core->TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
+    d_4_3_Core->f.TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
 {
-    d_4_3_Core->CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
+    d_4_3_Core->f.CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDispatchComputeIndirect(GLintptr indirect)
 {
-    d_4_3_Core->DispatchComputeIndirect(indirect);
+    d_4_3_Core->f.DispatchComputeIndirect(indirect);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
 {
-    d_4_3_Core->DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
+    d_4_3_Core->f.DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
 {
-    d_4_3_Core->ClearBufferSubData(target, internalformat, offset, size, format, type, data);
+    d_4_3_Core->f.ClearBufferSubData(target, internalformat, offset, size, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_3_Core::glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)
 {
-    d_4_3_Core->ClearBufferData(target, internalformat, format, type, data);
+    d_4_3_Core->f.ClearBufferData(target, internalformat, format, type, data);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_4_4_compatibility.cpp b/src/gui/opengl/qopenglfunctions_4_4_compatibility.cpp
index 0f0bf925c9d..8cbb94c1a1a 100644
--- a/src/gui/opengl/qopenglfunctions_4_4_compatibility.cpp
+++ b/src/gui/opengl/qopenglfunctions_4_4_compatibility.cpp
@@ -95,98 +95,75 @@ QOpenGLFunctions_4_4_Compatibility::QOpenGLFunctions_4_4_Compatibility()
 
 QOpenGLFunctions_4_4_Compatibility::~QOpenGLFunctions_4_4_Compatibility()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
-    if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        delete d_3_2_Core;
-    }
-    if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        delete d_3_3_Core;
-    }
-    if (d_4_0_Core && !d_4_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_0_Core->context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        delete d_4_0_Core;
-    }
-    if (d_4_1_Core && !d_4_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_1_Core->context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        delete d_4_1_Core;
-    }
-    if (d_4_2_Core && !d_4_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_2_Core->context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        delete d_4_2_Core;
-    }
-    if (d_4_3_Core && !d_4_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_3_Core->context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        delete d_4_3_Core;
-    }
-    if (d_4_4_Core && !d_4_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_4_Core->context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
-        delete d_4_4_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
-    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        delete d_1_1_Deprecated;
-    }
-    if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        delete d_1_2_Deprecated;
-    }
-    if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        delete d_1_3_Deprecated;
-    }
-    if (d_1_4_Deprecated && !d_1_4_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        delete d_1_4_Deprecated;
-    }
-    if (d_3_3_Deprecated && !d_3_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Deprecated->context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        delete d_3_3_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
+    if (d_3_2_Core)
+        d_3_2_Core->refs.deref();
+    Q_ASSERT(d_3_2_Core->refs.load());
+    if (d_3_3_Core)
+        d_3_3_Core->refs.deref();
+    Q_ASSERT(d_3_3_Core->refs.load());
+    if (d_4_0_Core)
+        d_4_0_Core->refs.deref();
+    Q_ASSERT(d_4_0_Core->refs.load());
+    if (d_4_1_Core)
+        d_4_1_Core->refs.deref();
+    Q_ASSERT(d_4_1_Core->refs.load());
+    if (d_4_2_Core)
+        d_4_2_Core->refs.deref();
+    Q_ASSERT(d_4_2_Core->refs.load());
+    if (d_4_3_Core)
+        d_4_3_Core->refs.deref();
+    Q_ASSERT(d_4_3_Core->refs.load());
+    if (d_4_4_Core)
+        d_4_4_Core->refs.deref();
+    Q_ASSERT(d_4_4_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
+    if (d_1_1_Deprecated)
+        d_1_1_Deprecated->refs.deref();
+    Q_ASSERT(d_1_1_Deprecated->refs.load());
+    if (d_1_2_Deprecated)
+        d_1_2_Deprecated->refs.deref();
+    Q_ASSERT(d_1_2_Deprecated->refs.load());
+    if (d_1_3_Deprecated)
+        d_1_3_Deprecated->refs.deref();
+    Q_ASSERT(d_1_3_Deprecated->refs.load());
+    if (d_1_4_Deprecated)
+        d_1_4_Deprecated->refs.deref();
+    Q_ASSERT(d_1_4_Deprecated->refs.load());
+    if (d_3_3_Deprecated)
+        d_3_3_Deprecated->refs.deref();
+    Q_ASSERT(d_3_3_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_4_4_Compatibility::initializeOpenGLFunctions()
@@ -205,186 +182,94 @@ bool QOpenGLFunctions_4_4_Compatibility::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
-        }
         d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
-        }
         d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus(), d);
-        }
         d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus(), d);
-        }
         d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus(), d);
-        }
         d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus(), d);
-        }
         d_4_3_Core = static_cast<QOpenGLFunctions_4_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus(), d);
-        }
         d_4_4_Core = static_cast<QOpenGLFunctions_4_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_4_4_compatibility.h b/src/gui/opengl/qopenglfunctions_4_4_compatibility.h
index 37fcbf5c2f3..d369ff27ff5 100644
--- a/src/gui/opengl/qopenglfunctions_4_4_compatibility.h
+++ b/src/gui/opengl/qopenglfunctions_4_4_compatibility.h
@@ -1,9 +1,10 @@
 /****************************************************************************
 **
 ** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
-** This file is part of the QtWidgets module of the Qt Toolkit.
+** This file is part of the QtGui module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** Commercial License Usage
@@ -1122,4664 +1123,4664 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_4_4_Compatibility::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_4_Compatibility::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetIntegerv(GLenum pname, GLint *data)
 {
-    d_1_0_Core->GetIntegerv(pname, data);
+    d_1_0_Core->f.GetIntegerv(pname, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetFloatv(GLenum pname, GLfloat *data)
 {
-    d_1_0_Core->GetFloatv(pname, data);
+    d_1_0_Core->f.GetFloatv(pname, data);
 }
 
 inline GLenum QOpenGLFunctions_4_4_Compatibility::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetDoublev(GLenum pname, GLdouble *data)
 {
-    d_1_0_Core->GetDoublev(pname, data);
+    d_1_0_Core->f.GetDoublev(pname, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetBooleanv(GLenum pname, GLboolean *data)
 {
-    d_1_0_Core->GetBooleanv(pname, data);
+    d_1_0_Core->f.GetBooleanv(pname, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glReadBuffer(GLenum src)
 {
-    d_1_0_Core->ReadBuffer(src);
+    d_1_0_Core->f.ReadBuffer(src);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawBuffer(GLenum buf)
 {
-    d_1_0_Core->DrawBuffer(buf);
+    d_1_0_Core->f.DrawBuffer(buf);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_4_4_Compatibility::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_4_4_Compatibility::glGetCompressedTexImage(GLenum target, GLint level, void *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_4_4_Compatibility::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_4_4_Compatibility::glGetBufferPointerv(GLenum target, GLenum pname, void * *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline void * QOpenGLFunctions_4_4_Compatibility::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4usv(index, v);
+    d_2_0_Core->f.VertexAttrib4usv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4uiv(index, v);
+    d_2_0_Core->f.VertexAttrib4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4ubv(index, v);
+    d_2_0_Core->f.VertexAttrib4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4sv(index, v);
+    d_2_0_Core->f.VertexAttrib4sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4iv(index, v);
+    d_2_0_Core->f.VertexAttrib4iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib4fv(index, v);
+    d_2_0_Core->f.VertexAttrib4fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib4dv(index, v);
+    d_2_0_Core->f.VertexAttrib4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4bv(index, v);
+    d_2_0_Core->f.VertexAttrib4bv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4Nusv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4Nuiv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nubv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
 {
-    d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4Nsv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4Niv(index, v);
+    d_2_0_Core->f.VertexAttrib4Niv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nbv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib3sv(index, v);
+    d_2_0_Core->f.VertexAttrib3sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
 {
-    d_2_0_Core->VertexAttrib3s(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib3fv(index, v);
+    d_2_0_Core->f.VertexAttrib3fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_2_0_Core->VertexAttrib3f(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib3dv(index, v);
+    d_2_0_Core->f.VertexAttrib3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_2_0_Core->VertexAttrib3d(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib2sv(index, v);
+    d_2_0_Core->f.VertexAttrib2sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
 {
-    d_2_0_Core->VertexAttrib2s(index, x, y);
+    d_2_0_Core->f.VertexAttrib2s(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib2fv(index, v);
+    d_2_0_Core->f.VertexAttrib2fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
 {
-    d_2_0_Core->VertexAttrib2f(index, x, y);
+    d_2_0_Core->f.VertexAttrib2f(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib2dv(index, v);
+    d_2_0_Core->f.VertexAttrib2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_2_0_Core->VertexAttrib2d(index, x, y);
+    d_2_0_Core->f.VertexAttrib2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib1sv(index, v);
+    d_2_0_Core->f.VertexAttrib1sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
 {
-    d_2_0_Core->VertexAttrib1s(index, x);
+    d_2_0_Core->f.VertexAttrib1s(index, x);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib1fv(index, v);
+    d_2_0_Core->f.VertexAttrib1fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
 {
-    d_2_0_Core->VertexAttrib1f(index, x);
+    d_2_0_Core->f.VertexAttrib1f(index, x);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib1dv(index, v);
+    d_2_0_Core->f.VertexAttrib1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
 {
-    d_2_0_Core->VertexAttrib1d(index, x);
+    d_2_0_Core->f.VertexAttrib1d(index, x);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glShaderSource(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetVertexAttribPointerv(GLuint index, GLenum pname, void * *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_4_4_Compatibility::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_4_4_Compatibility::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, shaders);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, shaders);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_4_4_Compatibility::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_4_4_Compatibility::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline void * QOpenGLFunctions_4_4_Compatibility::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_4_4_Compatibility::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_4_Compatibility::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_4_4_Compatibility::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
 {
-    d_3_0_Core->VertexAttribI4usv(index, v);
+    d_3_0_Core->f.VertexAttribI4usv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
 {
-    d_3_0_Core->VertexAttribI4ubv(index, v);
+    d_3_0_Core->f.VertexAttribI4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
 {
-    d_3_0_Core->VertexAttribI4sv(index, v);
+    d_3_0_Core->f.VertexAttribI4sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
 {
-    d_3_0_Core->VertexAttribI4bv(index, v);
+    d_3_0_Core->f.VertexAttribI4bv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI4uiv(index, v);
+    d_3_0_Core->f.VertexAttribI4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI3uiv(index, v);
+    d_3_0_Core->f.VertexAttribI3uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI2uiv(index, v);
+    d_3_0_Core->f.VertexAttribI2uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI1uiv(index, v);
+    d_3_0_Core->f.VertexAttribI1uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI4iv(index, v);
+    d_3_0_Core->f.VertexAttribI4iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI3iv(index, v);
+    d_3_0_Core->f.VertexAttribI3iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI2iv(index, v);
+    d_3_0_Core->f.VertexAttribI2iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI1iv(index, v);
+    d_3_0_Core->f.VertexAttribI1iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
 {
-    d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
 {
-    d_3_0_Core->VertexAttribI3ui(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
 {
-    d_3_0_Core->VertexAttribI2ui(index, x, y);
+    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
 {
-    d_3_0_Core->VertexAttribI1ui(index, x);
+    d_3_0_Core->f.VertexAttribI1ui(index, x);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
 {
-    d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
 {
-    d_3_0_Core->VertexAttribI3i(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
 {
-    d_3_0_Core->VertexAttribI2i(index, x, y);
+    d_3_0_Core->f.VertexAttribI2i(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
 {
-    d_3_0_Core->VertexAttribI1i(index, x);
+    d_3_0_Core->f.VertexAttribI1i(index, x);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_4_4_Compatibility::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
 // OpenGL 3.2 core functions
 inline void QOpenGLFunctions_4_4_Compatibility::glSampleMaski(GLuint maskNumber, GLbitfield mask)
 {
-    d_3_2_Core->SampleMaski(maskNumber, mask);
+    d_3_2_Core->f.SampleMaski(maskNumber, mask);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
 {
-    d_3_2_Core->GetMultisamplefv(pname, index, val);
+    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
-    d_3_2_Core->FramebufferTexture(target, attachment, texture, level);
+    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetBufferParameteri64v(target, pname, params);
+    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64i_v(target, index, data);
+    d_3_2_Core->f.GetInteger64i_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
-    d_3_2_Core->GetSynciv(sync, pname, bufSize, length, values);
+    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetInteger64v(GLenum pname, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64v(pname, data);
+    d_3_2_Core->f.GetInteger64v(pname, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    d_3_2_Core->WaitSync(sync, flags, timeout);
+    d_3_2_Core->f.WaitSync(sync, flags, timeout);
 }
 
 inline GLenum QOpenGLFunctions_4_4_Compatibility::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    return d_3_2_Core->ClientWaitSync(sync, flags, timeout);
+    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDeleteSync(GLsync sync)
 {
-    d_3_2_Core->DeleteSync(sync);
+    d_3_2_Core->f.DeleteSync(sync);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsSync(GLsync sync)
 {
-    return d_3_2_Core->IsSync(sync);
+    return d_3_2_Core->f.IsSync(sync);
 }
 
 inline GLsync QOpenGLFunctions_4_4_Compatibility::glFenceSync(GLenum condition, GLbitfield flags)
 {
-    return d_3_2_Core->FenceSync(condition, flags);
+    return d_3_2_Core->f.FenceSync(condition, flags);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProvokingVertex(GLenum mode)
 {
-    d_3_2_Core->ProvokingVertex(mode);
+    d_3_2_Core->f.ProvokingVertex(mode);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex)
 {
-    d_3_2_Core->MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 }
 
 
 // OpenGL 3.3 core functions
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP4uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP4ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP3uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP3ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP2uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP2ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP1uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP1ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribDivisor(GLuint index, GLuint divisor)
 {
-    d_3_3_Core->VertexAttribDivisor(index, divisor);
+    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
 {
-    d_3_3_Core->GetQueryObjectui64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
 {
-    d_3_3_Core->GetQueryObjecti64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glQueryCounter(GLuint id, GLenum target)
 {
-    d_3_3_Core->QueryCounter(id, target);
+    d_3_3_Core->f.QueryCounter(id, target);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
 {
-    d_3_3_Core->GetSamplerParameterIuiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
 {
-    d_3_3_Core->GetSamplerParameterfv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameterIiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameteriv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
 {
-    d_3_3_Core->SamplerParameterIuiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameterIiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
 {
-    d_3_3_Core->SamplerParameterfv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
 {
-    d_3_3_Core->SamplerParameterf(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameteriv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
-    d_3_3_Core->SamplerParameteri(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindSampler(GLuint unit, GLuint sampler)
 {
-    d_3_3_Core->BindSampler(unit, sampler);
+    d_3_3_Core->f.BindSampler(unit, sampler);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsSampler(GLuint sampler)
 {
-    return d_3_3_Core->IsSampler(sampler);
+    return d_3_3_Core->f.IsSampler(sampler);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDeleteSamplers(GLsizei count, const GLuint *samplers)
 {
-    d_3_3_Core->DeleteSamplers(count, samplers);
+    d_3_3_Core->f.DeleteSamplers(count, samplers);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGenSamplers(GLsizei count, GLuint *samplers)
 {
-    d_3_3_Core->GenSamplers(count, samplers);
+    d_3_3_Core->f.GenSamplers(count, samplers);
 }
 
 inline GLint QOpenGLFunctions_4_4_Compatibility::glGetFragDataIndex(GLuint program, const GLchar *name)
 {
-    return d_3_3_Core->GetFragDataIndex(program, name);
+    return d_3_3_Core->f.GetFragDataIndex(program, name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
 {
-    d_3_3_Core->BindFragDataLocationIndexed(program, colorNumber, index, name);
+    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
 }
 
 
 // OpenGL 4.0 core functions
 inline void QOpenGLFunctions_4_4_Compatibility::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
 {
-    d_4_0_Core->GetQueryIndexediv(target, index, pname, params);
+    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEndQueryIndexed(GLenum target, GLuint index)
 {
-    d_4_0_Core->EndQueryIndexed(target, index);
+    d_4_0_Core->f.EndQueryIndexed(target, index);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
 {
-    d_4_0_Core->BeginQueryIndexed(target, index, id);
+    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
 {
-    d_4_0_Core->DrawTransformFeedbackStream(mode, id, stream);
+    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawTransformFeedback(GLenum mode, GLuint id)
 {
-    d_4_0_Core->DrawTransformFeedback(mode, id);
+    d_4_0_Core->f.DrawTransformFeedback(mode, id);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glResumeTransformFeedback()
 {
-    d_4_0_Core->ResumeTransformFeedback();
+    d_4_0_Core->f.ResumeTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPauseTransformFeedback()
 {
-    d_4_0_Core->PauseTransformFeedback();
+    d_4_0_Core->f.PauseTransformFeedback();
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsTransformFeedback(GLuint id)
 {
-    return d_4_0_Core->IsTransformFeedback(id);
+    return d_4_0_Core->f.IsTransformFeedback(id);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
 {
-    d_4_0_Core->GenTransformFeedbacks(n, ids);
+    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
 {
-    d_4_0_Core->DeleteTransformFeedbacks(n, ids);
+    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindTransformFeedback(GLenum target, GLuint id)
 {
-    d_4_0_Core->BindTransformFeedback(target, id);
+    d_4_0_Core->f.BindTransformFeedback(target, id);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPatchParameterfv(GLenum pname, const GLfloat *values)
 {
-    d_4_0_Core->PatchParameterfv(pname, values);
+    d_4_0_Core->f.PatchParameterfv(pname, values);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPatchParameteri(GLenum pname, GLint value)
 {
-    d_4_0_Core->PatchParameteri(pname, value);
+    d_4_0_Core->f.PatchParameteri(pname, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetProgramStageiv(program, shadertype, pname, values);
+    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
 {
-    d_4_0_Core->GetUniformSubroutineuiv(shadertype, location, params);
+    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
 {
-    d_4_0_Core->UniformSubroutinesuiv(shadertype, count, indices);
+    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
+    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
 }
 
 inline GLuint QOpenGLFunctions_4_4_Compatibility::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineIndex(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
 }
 
 inline GLint QOpenGLFunctions_4_4_Compatibility::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineUniformLocation(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
 {
-    d_4_0_Core->GetUniformdv(program, location, params);
+    d_4_0_Core->f.GetUniformdv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform4dv(location, count, value);
+    d_4_0_Core->f.Uniform4dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform3dv(location, count, value);
+    d_4_0_Core->f.Uniform3dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform2dv(location, count, value);
+    d_4_0_Core->f.Uniform2dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform1dv(location, count, value);
+    d_4_0_Core->f.Uniform1dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_0_Core->Uniform4d(location, x, y, z, w);
+    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_0_Core->Uniform3d(location, x, y, z);
+    d_4_0_Core->f.Uniform3d(location, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform2d(GLint location, GLdouble x, GLdouble y)
 {
-    d_4_0_Core->Uniform2d(location, x, y);
+    d_4_0_Core->f.Uniform2d(location, x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUniform1d(GLint location, GLdouble x)
 {
-    d_4_0_Core->Uniform1d(location, x);
+    d_4_0_Core->f.Uniform1d(location, x);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
 {
-    d_4_0_Core->DrawElementsIndirect(mode, type, indirect);
+    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawArraysIndirect(GLenum mode, const void *indirect)
 {
-    d_4_0_Core->DrawArraysIndirect(mode, indirect);
+    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-    d_4_0_Core->BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
 {
-    d_4_0_Core->BlendFunci(buf, src, dst);
+    d_4_0_Core->f.BlendFunci(buf, src, dst);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
 {
-    d_4_0_Core->BlendEquationSeparatei(buf, modeRGB, modeAlpha);
+    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBlendEquationi(GLuint buf, GLenum mode)
 {
-    d_4_0_Core->BlendEquationi(buf, mode);
+    d_4_0_Core->f.BlendEquationi(buf, mode);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMinSampleShading(GLfloat value)
 {
-    d_4_0_Core->MinSampleShading(value);
+    d_4_0_Core->f.MinSampleShading(value);
 }
 
 
 // OpenGL 4.1 core functions
 inline void QOpenGLFunctions_4_4_Compatibility::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
 {
-    d_4_1_Core->GetDoublei_v(target, index, data);
+    d_4_1_Core->f.GetDoublei_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
 {
-    d_4_1_Core->GetFloati_v(target, index, data);
+    d_4_1_Core->f.GetFloati_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
 {
-    d_4_1_Core->DepthRangeIndexed(index, n, f);
+    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
 {
-    d_4_1_Core->DepthRangeArrayv(first, count, v);
+    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glScissorIndexedv(GLuint index, const GLint *v)
 {
-    d_4_1_Core->ScissorIndexedv(index, v);
+    d_4_1_Core->f.ScissorIndexedv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
 {
-    d_4_1_Core->ScissorIndexed(index, left, bottom, width, height);
+    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
 {
-    d_4_1_Core->ScissorArrayv(first, count, v);
+    d_4_1_Core->f.ScissorArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glViewportIndexedfv(GLuint index, const GLfloat *v)
 {
-    d_4_1_Core->ViewportIndexedfv(index, v);
+    d_4_1_Core->f.ViewportIndexedfv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
 {
-    d_4_1_Core->ViewportIndexedf(index, x, y, w, h);
+    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
 {
-    d_4_1_Core->ViewportArrayv(first, count, v);
+    d_4_1_Core->f.ViewportArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_4_1_Core->GetVertexAttribLdv(index, pname, params);
+    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
-    d_4_1_Core->VertexAttribLPointer(index, size, type, stride, pointer);
+    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribL4dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL4dv(index, v);
+    d_4_1_Core->f.VertexAttribL4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribL3dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL3dv(index, v);
+    d_4_1_Core->f.VertexAttribL3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribL2dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL2dv(index, v);
+    d_4_1_Core->f.VertexAttribL2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribL1dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL1dv(index, v);
+    d_4_1_Core->f.VertexAttribL1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_1_Core->VertexAttribL4d(index, x, y, z, w);
+    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_1_Core->VertexAttribL3d(index, x, y, z);
+    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_4_1_Core->VertexAttribL2d(index, x, y);
+    d_4_1_Core->f.VertexAttribL2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribL1d(GLuint index, GLdouble x)
 {
-    d_4_1_Core->VertexAttribL1d(index, x);
+    d_4_1_Core->f.VertexAttribL1d(index, x);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_4_1_Core->GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glValidateProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->ValidateProgramPipeline(pipeline);
+    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform4uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_4_1_Core->ProgramUniform4ui(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform4dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
 {
-    d_4_1_Core->ProgramUniform4d(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform4fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_4_1_Core->ProgramUniform4f(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform4iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_4_1_Core->ProgramUniform4i(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform3uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_4_1_Core->ProgramUniform3ui(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform3dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
 {
-    d_4_1_Core->ProgramUniform3d(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform3fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_4_1_Core->ProgramUniform3f(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform3iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_4_1_Core->ProgramUniform3i(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform2uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
 {
-    d_4_1_Core->ProgramUniform2ui(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform2dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
 {
-    d_4_1_Core->ProgramUniform2d(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform2fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
 {
-    d_4_1_Core->ProgramUniform2f(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform2iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
 {
-    d_4_1_Core->ProgramUniform2i(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform1uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
 {
-    d_4_1_Core->ProgramUniform1ui(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform1dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
 {
-    d_4_1_Core->ProgramUniform1d(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform1fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
 {
-    d_4_1_Core->ProgramUniform1f(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform1iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramUniform1i(GLuint program, GLint location, GLint v0)
 {
-    d_4_1_Core->ProgramUniform1i(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
 {
-    d_4_1_Core->GetProgramPipelineiv(pipeline, pname, params);
+    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsProgramPipeline(GLuint pipeline)
 {
-    return d_4_1_Core->IsProgramPipeline(pipeline);
+    return d_4_1_Core->f.IsProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
 {
-    d_4_1_Core->GenProgramPipelines(n, pipelines);
+    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
 {
-    d_4_1_Core->DeleteProgramPipelines(n, pipelines);
+    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->BindProgramPipeline(pipeline);
+    d_4_1_Core->f.BindProgramPipeline(pipeline);
 }
 
 inline GLuint QOpenGLFunctions_4_4_Compatibility::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
 {
-    return d_4_1_Core->CreateShaderProgramv(type, count, strings);
+    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glActiveShaderProgram(GLuint pipeline, GLuint program)
 {
-    d_4_1_Core->ActiveShaderProgram(pipeline, program);
+    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
 {
-    d_4_1_Core->UseProgramStages(pipeline, stages, program);
+    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramParameteri(GLuint program, GLenum pname, GLint value)
 {
-    d_4_1_Core->ProgramParameteri(program, pname, value);
+    d_4_1_Core->f.ProgramParameteri(program, pname, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
 {
-    d_4_1_Core->ProgramBinary(program, binaryFormat, binary, length);
+    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)
 {
-    d_4_1_Core->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
+    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClearDepthf(GLfloat dd)
 {
-    d_4_1_Core->ClearDepthf(dd);
+    d_4_1_Core->f.ClearDepthf(dd);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDepthRangef(GLfloat n, GLfloat f)
 {
-    d_4_1_Core->DepthRangef(n, f);
+    d_4_1_Core->f.DepthRangef(n, f);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
 {
-    d_4_1_Core->GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length)
 {
-    d_4_1_Core->ShaderBinary(count, shaders, binaryformat, binary, length);
+    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glReleaseShaderCompiler()
 {
-    d_4_1_Core->ReleaseShaderCompiler();
+    d_4_1_Core->f.ReleaseShaderCompiler();
 }
 
 
 // OpenGL 4.2 core functions
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
 {
-    d_4_2_Core->DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
+    d_4_2_Core->f.DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
 {
-    d_4_2_Core->DrawTransformFeedbackInstanced(mode, id, instancecount);
+    d_4_2_Core->f.DrawTransformFeedbackInstanced(mode, id, instancecount);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
-    d_4_2_Core->TexStorage3D(target, levels, internalformat, width, height, depth);
+    d_4_2_Core->f.TexStorage3D(target, levels, internalformat, width, height, depth);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_4_2_Core->TexStorage2D(target, levels, internalformat, width, height);
+    d_4_2_Core->f.TexStorage2D(target, levels, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
 {
-    d_4_2_Core->TexStorage1D(target, levels, internalformat, width);
+    d_4_2_Core->f.TexStorage1D(target, levels, internalformat, width);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMemoryBarrier(GLbitfield barriers)
 {
-    d_4_2_Core->MemoryBarrier(barriers);
+    d_4_2_Core->f.MemoryBarrier(barriers);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
 {
-    d_4_2_Core->BindImageTexture(unit, texture, level, layered, layer, access, format);
+    d_4_2_Core->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
 {
-    d_4_2_Core->GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
+    d_4_2_Core->f.GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
 {
-    d_4_2_Core->GetInternalformativ(target, internalformat, pname, bufSize, params);
+    d_4_2_Core->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
 {
-    d_4_2_Core->DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
+    d_4_2_Core->f.DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
 {
-    d_4_2_Core->DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
+    d_4_2_Core->f.DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
 {
-    d_4_2_Core->DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
+    d_4_2_Core->f.DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
 }
 
 
 // OpenGL 4.3 core functions
 inline void QOpenGLFunctions_4_4_Compatibility::glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
 {
-    d_4_3_Core->GetObjectPtrLabel(ptr, bufSize, length, label);
+    d_4_3_Core->f.GetObjectPtrLabel(ptr, bufSize, length, label);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label)
 {
-    d_4_3_Core->ObjectPtrLabel(ptr, length, label);
+    d_4_3_Core->f.ObjectPtrLabel(ptr, length, label);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
 {
-    d_4_3_Core->GetObjectLabel(identifier, name, bufSize, length, label);
+    d_4_3_Core->f.GetObjectLabel(identifier, name, bufSize, length, label);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
 {
-    d_4_3_Core->ObjectLabel(identifier, name, length, label);
+    d_4_3_Core->f.ObjectLabel(identifier, name, length, label);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPopDebugGroup()
 {
-    d_4_3_Core->PopDebugGroup();
+    d_4_3_Core->f.PopDebugGroup();
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message)
 {
-    d_4_3_Core->PushDebugGroup(source, id, length, message);
+    d_4_3_Core->f.PushDebugGroup(source, id, length, message);
 }
 
 inline GLuint QOpenGLFunctions_4_4_Compatibility::glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
 {
-    return d_4_3_Core->GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
+    return d_4_3_Core->f.GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
 {
-    d_4_3_Core->DebugMessageCallback(callback, userParam);
+    d_4_3_Core->f.DebugMessageCallback(callback, userParam);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
 {
-    d_4_3_Core->DebugMessageInsert(source, type, id, severity, length, buf);
+    d_4_3_Core->f.DebugMessageInsert(source, type, id, severity, length, buf);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)
 {
-    d_4_3_Core->DebugMessageControl(source, type, severity, count, ids, enabled);
+    d_4_3_Core->f.DebugMessageControl(source, type, severity, count, ids, enabled);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
 {
-    d_4_3_Core->VertexBindingDivisor(bindingindex, divisor);
+    d_4_3_Core->f.VertexBindingDivisor(bindingindex, divisor);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
 {
-    d_4_3_Core->VertexAttribBinding(attribindex, bindingindex);
+    d_4_3_Core->f.VertexAttribBinding(attribindex, bindingindex);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribLFormat(attribindex, size, type, relativeoffset);
+    d_4_3_Core->f.VertexAttribLFormat(attribindex, size, type, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribIFormat(attribindex, size, type, relativeoffset);
+    d_4_3_Core->f.VertexAttribIFormat(attribindex, size, type, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
+    d_4_3_Core->f.VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
 {
-    d_4_3_Core->BindVertexBuffer(bindingindex, buffer, offset, stride);
+    d_4_3_Core->f.BindVertexBuffer(bindingindex, buffer, offset, stride);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
 {
-    d_4_3_Core->TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
+    d_4_3_Core->f.TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_4_3_Core->TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_4_3_Core->f.TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_4_3_Core->TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_4_3_Core->f.TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_4_3_Core->TexBufferRange(target, internalformat, buffer, offset, size);
+    d_4_3_Core->f.TexBufferRange(target, internalformat, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
 {
-    d_4_3_Core->ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
+    d_4_3_Core->f.ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
 }
 
 inline GLint QOpenGLFunctions_4_4_Compatibility::glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceLocationIndex(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceLocationIndex(program, programInterface, name);
 }
 
 inline GLint QOpenGLFunctions_4_4_Compatibility::glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceLocation(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceLocation(program, programInterface, name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
 {
-    d_4_3_Core->GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
+    d_4_3_Core->f.GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
 {
-    d_4_3_Core->GetProgramResourceName(program, programInterface, index, bufSize, length, name);
+    d_4_3_Core->f.GetProgramResourceName(program, programInterface, index, bufSize, length, name);
 }
 
 inline GLuint QOpenGLFunctions_4_4_Compatibility::glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceIndex(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceIndex(program, programInterface, name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params)
 {
-    d_4_3_Core->GetProgramInterfaceiv(program, programInterface, pname, params);
+    d_4_3_Core->f.GetProgramInterfaceiv(program, programInterface, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
 {
-    d_4_3_Core->MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
+    d_4_3_Core->f.MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
 {
-    d_4_3_Core->MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
+    d_4_3_Core->f.MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_4_3_Core->InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
+    d_4_3_Core->f.InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
 {
-    d_4_3_Core->InvalidateFramebuffer(target, numAttachments, attachments);
+    d_4_3_Core->f.InvalidateFramebuffer(target, numAttachments, attachments);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glInvalidateBufferData(GLuint buffer)
 {
-    d_4_3_Core->InvalidateBufferData(buffer);
+    d_4_3_Core->f.InvalidateBufferData(buffer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
 {
-    d_4_3_Core->InvalidateBufferSubData(buffer, offset, length);
+    d_4_3_Core->f.InvalidateBufferSubData(buffer, offset, length);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glInvalidateTexImage(GLuint texture, GLint level)
 {
-    d_4_3_Core->InvalidateTexImage(texture, level);
+    d_4_3_Core->f.InvalidateTexImage(texture, level);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
 {
-    d_4_3_Core->InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
+    d_4_3_Core->f.InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)
 {
-    d_4_3_Core->GetInternalformati64v(target, internalformat, pname, bufSize, params);
+    d_4_3_Core->f.GetInternalformati64v(target, internalformat, pname, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_4_3_Core->GetFramebufferParameteriv(target, pname, params);
+    d_4_3_Core->f.GetFramebufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_4_3_Core->FramebufferParameteri(target, pname, param);
+    d_4_3_Core->f.FramebufferParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
 {
-    d_4_3_Core->CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
+    d_4_3_Core->f.CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDispatchComputeIndirect(GLintptr indirect)
 {
-    d_4_3_Core->DispatchComputeIndirect(indirect);
+    d_4_3_Core->f.DispatchComputeIndirect(indirect);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
 {
-    d_4_3_Core->DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
+    d_4_3_Core->f.DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
 {
-    d_4_3_Core->ClearBufferSubData(target, internalformat, offset, size, format, type, data);
+    d_4_3_Core->f.ClearBufferSubData(target, internalformat, offset, size, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)
 {
-    d_4_3_Core->ClearBufferData(target, internalformat, format, type, data);
+    d_4_3_Core->f.ClearBufferData(target, internalformat, format, type, data);
 }
 
 
 // OpenGL 4.4 core functions
 inline void QOpenGLFunctions_4_4_Compatibility::glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
 {
-    d_4_4_Core->BindVertexBuffers(first, count, buffers, offsets, strides);
+    d_4_4_Core->f.BindVertexBuffers(first, count, buffers, offsets, strides);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures)
 {
-    d_4_4_Core->BindImageTextures(first, count, textures);
+    d_4_4_Core->f.BindImageTextures(first, count, textures);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers)
 {
-    d_4_4_Core->BindSamplers(first, count, samplers);
+    d_4_4_Core->f.BindSamplers(first, count, samplers);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindTextures(GLuint first, GLsizei count, const GLuint *textures)
 {
-    d_4_4_Core->BindTextures(first, count, textures);
+    d_4_4_Core->f.BindTextures(first, count, textures);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes)
 {
-    d_4_4_Core->BindBuffersRange(target, first, count, buffers, offsets, sizes);
+    d_4_4_Core->f.BindBuffersRange(target, first, count, buffers, offsets, sizes);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers)
 {
-    d_4_4_Core->BindBuffersBase(target, first, count, buffers);
+    d_4_4_Core->f.BindBuffersBase(target, first, count, buffers);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data)
 {
-    d_4_4_Core->ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
+    d_4_4_Core->f.ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data)
 {
-    d_4_4_Core->ClearTexImage(texture, level, format, type, data);
+    d_4_4_Core->f.ClearTexImage(texture, level, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)
 {
-    d_4_4_Core->BufferStorage(target, size, data, flags);
+    d_4_4_Core->f.BufferStorage(target, size, data, flags);
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_4_4_Compatibility::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_4_4_Compatibility::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_4_4_Compatibility::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCallLists(GLsizei n, GLenum type, const void *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
 // OpenGL 1.1 deprecated functions
 inline void QOpenGLFunctions_4_4_Compatibility::glPushClientAttrib(GLbitfield mask)
 {
-    d_1_1_Deprecated->PushClientAttrib(mask);
+    d_1_1_Deprecated->f.PushClientAttrib(mask);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPopClientAttrib()
 {
-    d_1_1_Deprecated->PopClientAttrib();
+    d_1_1_Deprecated->f.PopClientAttrib();
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glIndexubv(const GLubyte *c)
 {
-    d_1_1_Deprecated->Indexubv(c);
+    d_1_1_Deprecated->f.Indexubv(c);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glIndexub(GLubyte c)
 {
-    d_1_1_Deprecated->Indexub(c);
+    d_1_1_Deprecated->f.Indexub(c);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 {
-    d_1_1_Deprecated->PrioritizeTextures(n, textures, priorities);
+    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Compatibility::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-    return d_1_1_Deprecated->AreTexturesResident(n, textures, residences);
+    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
-    d_1_1_Deprecated->VertexPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
-    d_1_1_Deprecated->TexCoordPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glNormalPointer(GLenum type, GLsizei stride, const void *pointer)
 {
-    d_1_1_Deprecated->NormalPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glInterleavedArrays(GLenum format, GLsizei stride, const void *pointer)
 {
-    d_1_1_Deprecated->InterleavedArrays(format, stride, pointer);
+    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetPointerv(GLenum pname, void * *params)
 {
-    d_1_1_Deprecated->GetPointerv(pname, params);
+    d_1_1_Deprecated->f.GetPointerv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glIndexPointer(GLenum type, GLsizei stride, const void *pointer)
 {
-    d_1_1_Deprecated->IndexPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEnableClientState(GLenum array)
 {
-    d_1_1_Deprecated->EnableClientState(array);
+    d_1_1_Deprecated->f.EnableClientState(array);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glEdgeFlagPointer(GLsizei stride, const void *pointer)
 {
-    d_1_1_Deprecated->EdgeFlagPointer(stride, pointer);
+    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glDisableClientState(GLenum array)
 {
-    d_1_1_Deprecated->DisableClientState(array);
+    d_1_1_Deprecated->f.DisableClientState(array);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
-    d_1_1_Deprecated->ColorPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glArrayElement(GLint i)
 {
-    d_1_1_Deprecated->ArrayElement(i);
+    d_1_1_Deprecated->f.ArrayElement(i);
 }
 
 
 // OpenGL 1.2 deprecated functions
 inline void QOpenGLFunctions_4_4_Compatibility::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table)
 {
-    d_1_2_Deprecated->ColorTable(target, internalformat, width, format, type, table);
+    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorTable(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetColorTable(GLenum target, GLenum format, GLenum type, void *table)
 {
-    d_1_2_Deprecated->GetColorTable(target, format, type, table);
+    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data)
 {
-    d_1_2_Deprecated->ColorSubTable(target, start, count, format, type, data);
+    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorSubTable(target, start, x, y, width);
+    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter1D(target, internalformat, width, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
 {
-    d_1_2_Deprecated->ConvolutionParameterf(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
 {
-    d_1_2_Deprecated->ConvolutionParameteri(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter1D(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
+    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, void *image)
 {
-    d_1_2_Deprecated->GetConvolutionFilter(target, format, type, image);
+    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, void *row, void *column, void *span)
 {
-    d_1_2_Deprecated->GetSeparableFilter(target, format, type, row, column, span);
+    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column)
 {
-    d_1_2_Deprecated->SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
+    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, void *values)
 {
-    d_1_2_Deprecated->GetHistogram(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetHistogramParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetHistogramParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, void *values)
 {
-    d_1_2_Deprecated->GetMinmax(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Histogram(target, width, internalformat, sink);
+    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Minmax(target, internalformat, sink);
+    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glResetHistogram(GLenum target)
 {
-    d_1_2_Deprecated->ResetHistogram(target);
+    d_1_2_Deprecated->f.ResetHistogram(target);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glResetMinmax(GLenum target)
 {
-    d_1_2_Deprecated->ResetMinmax(target);
+    d_1_2_Deprecated->f.ResetMinmax(target);
 }
 
 
 // OpenGL 1.3 deprecated functions
 inline void QOpenGLFunctions_4_4_Compatibility::glMultTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixd(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixf(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLoadTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixd(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glLoadTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixf(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord4sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_3_Deprecated->MultiTexCoord4s(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord4iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_3_Deprecated->MultiTexCoord4i(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_3_Deprecated->MultiTexCoord4f(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_3_Deprecated->MultiTexCoord4d(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord3sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
 {
-    d_1_3_Deprecated->MultiTexCoord3s(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord3iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
 {
-    d_1_3_Deprecated->MultiTexCoord3i(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_3_Deprecated->MultiTexCoord3f(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_3_Deprecated->MultiTexCoord3d(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord2sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
 {
-    d_1_3_Deprecated->MultiTexCoord2s(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord2iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
 {
-    d_1_3_Deprecated->MultiTexCoord2i(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
 {
-    d_1_3_Deprecated->MultiTexCoord2f(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
 {
-    d_1_3_Deprecated->MultiTexCoord2d(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord1sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord1s(GLenum target, GLshort s)
 {
-    d_1_3_Deprecated->MultiTexCoord1s(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord1iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord1i(GLenum target, GLint s)
 {
-    d_1_3_Deprecated->MultiTexCoord1i(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord1f(GLenum target, GLfloat s)
 {
-    d_1_3_Deprecated->MultiTexCoord1f(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoord1d(GLenum target, GLdouble s)
 {
-    d_1_3_Deprecated->MultiTexCoord1d(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glClientActiveTexture(GLenum texture)
 {
-    d_1_3_Deprecated->ClientActiveTexture(texture);
+    d_1_3_Deprecated->f.ClientActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 deprecated functions
 inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos3sv(v);
+    d_1_4_Deprecated->f.WindowPos3sv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_4_Deprecated->WindowPos3s(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos3iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos3iv(v);
+    d_1_4_Deprecated->f.WindowPos3iv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_4_Deprecated->WindowPos3i(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos3fv(v);
+    d_1_4_Deprecated->f.WindowPos3fv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_4_Deprecated->WindowPos3f(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos3dv(v);
+    d_1_4_Deprecated->f.WindowPos3dv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_4_Deprecated->WindowPos3d(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos2sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos2sv(v);
+    d_1_4_Deprecated->f.WindowPos2sv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos2s(GLshort x, GLshort y)
 {
-    d_1_4_Deprecated->WindowPos2s(x, y);
+    d_1_4_Deprecated->f.WindowPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos2iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos2iv(v);
+    d_1_4_Deprecated->f.WindowPos2iv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos2i(GLint x, GLint y)
 {
-    d_1_4_Deprecated->WindowPos2i(x, y);
+    d_1_4_Deprecated->f.WindowPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos2fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos2fv(v);
+    d_1_4_Deprecated->f.WindowPos2fv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos2f(GLfloat x, GLfloat y)
 {
-    d_1_4_Deprecated->WindowPos2f(x, y);
+    d_1_4_Deprecated->f.WindowPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos2dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos2dv(v);
+    d_1_4_Deprecated->f.WindowPos2dv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glWindowPos2d(GLdouble x, GLdouble y)
 {
-    d_1_4_Deprecated->WindowPos2d(x, y);
+    d_1_4_Deprecated->f.WindowPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
-    d_1_4_Deprecated->SecondaryColorPointer(size, type, stride, pointer);
+    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3usv(const GLushort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3usv(v);
+    d_1_4_Deprecated->f.SecondaryColor3usv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3us(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3uiv(const GLuint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3uiv(v);
+    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ui(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3ubv(const GLubyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3ubv(v);
+    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ub(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3sv(v);
+    d_1_4_Deprecated->f.SecondaryColor3sv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3s(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3iv(const GLint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3iv(v);
+    d_1_4_Deprecated->f.SecondaryColor3iv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3i(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->SecondaryColor3fv(v);
+    d_1_4_Deprecated->f.SecondaryColor3fv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_4_Deprecated->SecondaryColor3f(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->SecondaryColor3dv(v);
+    d_1_4_Deprecated->f.SecondaryColor3dv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_4_Deprecated->SecondaryColor3d(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3bv(const GLbyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3bv(v);
+    d_1_4_Deprecated->f.SecondaryColor3bv(v);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3b(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFogCoordPointer(GLenum type, GLsizei stride, const void *pointer)
 {
-    d_1_4_Deprecated->FogCoordPointer(type, stride, pointer);
+    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFogCoorddv(const GLdouble *coord)
 {
-    d_1_4_Deprecated->FogCoorddv(coord);
+    d_1_4_Deprecated->f.FogCoorddv(coord);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFogCoordd(GLdouble coord)
 {
-    d_1_4_Deprecated->FogCoordd(coord);
+    d_1_4_Deprecated->f.FogCoordd(coord);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFogCoordfv(const GLfloat *coord)
 {
-    d_1_4_Deprecated->FogCoordfv(coord);
+    d_1_4_Deprecated->f.FogCoordfv(coord);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glFogCoordf(GLfloat coord)
 {
-    d_1_4_Deprecated->FogCoordf(coord);
+    d_1_4_Deprecated->f.FogCoordf(coord);
 }
 
 
@@ -5798,152 +5799,152 @@ inline void QOpenGLFunctions_4_4_Compatibility::glFogCoordf(GLfloat coord)
 // OpenGL 3.3 deprecated functions
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->SecondaryColorP3uiv(type, color);
+    d_3_3_Deprecated->f.SecondaryColorP3uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->SecondaryColorP3ui(type, color);
+    d_3_3_Deprecated->f.SecondaryColorP3ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->ColorP4uiv(type, color);
+    d_3_3_Deprecated->f.ColorP4uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColorP4ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->ColorP4ui(type, color);
+    d_3_3_Deprecated->f.ColorP4ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->ColorP3uiv(type, color);
+    d_3_3_Deprecated->f.ColorP3uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glColorP3ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->ColorP3ui(type, color);
+    d_3_3_Deprecated->f.ColorP3ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->NormalP3uiv(type, coords);
+    d_3_3_Deprecated->f.NormalP3uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->NormalP3ui(type, coords);
+    d_3_3_Deprecated->f.NormalP3ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP4uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP4uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP4ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP4ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP3uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP3uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP3ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP3ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP2uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP2uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP2ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP2ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP1uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP1uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP1ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP1ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP4uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP4uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP4ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP4ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP3uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP3uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP3ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP3ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP2uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP2uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP2ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP2ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP1uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP1uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP1ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP1ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP4uiv(type, value);
+    d_3_3_Deprecated->f.VertexP4uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexP4ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP4ui(type, value);
+    d_3_3_Deprecated->f.VertexP4ui(type, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP3uiv(type, value);
+    d_3_3_Deprecated->f.VertexP3uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexP3ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP3ui(type, value);
+    d_3_3_Deprecated->f.VertexP3ui(type, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP2uiv(type, value);
+    d_3_3_Deprecated->f.VertexP2uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_4_Compatibility::glVertexP2ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP2ui(type, value);
+    d_3_3_Deprecated->f.VertexP2ui(type, value);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_4_4_core.cpp b/src/gui/opengl/qopenglfunctions_4_4_core.cpp
index dcf57f64b1f..95bfc3a4384 100644
--- a/src/gui/opengl/qopenglfunctions_4_4_core.cpp
+++ b/src/gui/opengl/qopenglfunctions_4_4_core.cpp
@@ -89,74 +89,57 @@ QOpenGLFunctions_4_4_Core::QOpenGLFunctions_4_4_Core()
 
 QOpenGLFunctions_4_4_Core::~QOpenGLFunctions_4_4_Core()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
-    if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        delete d_3_2_Core;
-    }
-    if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        delete d_3_3_Core;
-    }
-    if (d_4_0_Core && !d_4_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_0_Core->context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        delete d_4_0_Core;
-    }
-    if (d_4_1_Core && !d_4_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_1_Core->context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        delete d_4_1_Core;
-    }
-    if (d_4_2_Core && !d_4_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_2_Core->context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        delete d_4_2_Core;
-    }
-    if (d_4_3_Core && !d_4_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_3_Core->context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        delete d_4_3_Core;
-    }
-    if (d_4_4_Core && !d_4_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_4_Core->context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
-        delete d_4_4_Core;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
+    if (d_3_2_Core)
+        d_3_2_Core->refs.deref();
+    Q_ASSERT(d_3_2_Core->refs.load());
+    if (d_3_3_Core)
+        d_3_3_Core->refs.deref();
+    Q_ASSERT(d_3_3_Core->refs.load());
+    if (d_4_0_Core)
+        d_4_0_Core->refs.deref();
+    Q_ASSERT(d_4_0_Core->refs.load());
+    if (d_4_1_Core)
+        d_4_1_Core->refs.deref();
+    Q_ASSERT(d_4_1_Core->refs.load());
+    if (d_4_2_Core)
+        d_4_2_Core->refs.deref();
+    Q_ASSERT(d_4_2_Core->refs.load());
+    if (d_4_3_Core)
+        d_4_3_Core->refs.deref();
+    Q_ASSERT(d_4_3_Core->refs.load());
+    if (d_4_4_Core)
+        d_4_4_Core->refs.deref();
+    Q_ASSERT(d_4_4_Core->refs.load());
 }
 
 bool QOpenGLFunctions_4_4_Core::initializeOpenGLFunctions()
@@ -175,138 +158,70 @@ bool QOpenGLFunctions_4_4_Core::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
-        }
         d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
-        }
         d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus(), d);
-        }
         d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus(), d);
-        }
         d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus(), d);
-        }
         d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus(), d);
-        }
         d_4_3_Core = static_cast<QOpenGLFunctions_4_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus(), d);
-        }
         d_4_4_Core = static_cast<QOpenGLFunctions_4_4_CoreBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_4_4_core.h b/src/gui/opengl/qopenglfunctions_4_4_core.h
index 250352e8d04..e508478c50d 100644
--- a/src/gui/opengl/qopenglfunctions_4_4_core.h
+++ b/src/gui/opengl/qopenglfunctions_4_4_core.h
@@ -1,9 +1,10 @@
 /****************************************************************************
 **
 ** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
-** This file is part of the QtWidgets module of the Qt Toolkit.
+** This file is part of the QtGui module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** Commercial License Usage
@@ -670,2744 +671,2744 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_4_4_Core::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Core::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_4_Core::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetIntegerv(GLenum pname, GLint *data)
 {
-    d_1_0_Core->GetIntegerv(pname, data);
+    d_1_0_Core->f.GetIntegerv(pname, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetFloatv(GLenum pname, GLfloat *data)
 {
-    d_1_0_Core->GetFloatv(pname, data);
+    d_1_0_Core->f.GetFloatv(pname, data);
 }
 
 inline GLenum QOpenGLFunctions_4_4_Core::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetDoublev(GLenum pname, GLdouble *data)
 {
-    d_1_0_Core->GetDoublev(pname, data);
+    d_1_0_Core->f.GetDoublev(pname, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetBooleanv(GLenum pname, GLboolean *data)
 {
-    d_1_0_Core->GetBooleanv(pname, data);
+    d_1_0_Core->f.GetBooleanv(pname, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glReadBuffer(GLenum src)
 {
-    d_1_0_Core->ReadBuffer(src);
+    d_1_0_Core->f.ReadBuffer(src);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_4_4_Core::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_4_4_Core::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawBuffer(GLenum buf)
 {
-    d_1_0_Core->DrawBuffer(buf);
+    d_1_0_Core->f.DrawBuffer(buf);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline GLboolean QOpenGLFunctions_4_4_Core::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_4_4_Core::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_4_4_Core::glGetCompressedTexImage(GLenum target, GLint level, void *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_4_4_Core::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_4_4_Core::glGetBufferPointerv(GLenum target, GLenum pname, void * *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Core::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline void * QOpenGLFunctions_4_4_Core::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Core::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Core::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4usv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4usv(index, v);
+    d_2_0_Core->f.VertexAttrib4usv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4uiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4uiv(index, v);
+    d_2_0_Core->f.VertexAttrib4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4ubv(index, v);
+    d_2_0_Core->f.VertexAttrib4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4sv(index, v);
+    d_2_0_Core->f.VertexAttrib4sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4iv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4iv(index, v);
+    d_2_0_Core->f.VertexAttrib4iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib4fv(index, v);
+    d_2_0_Core->f.VertexAttrib4fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib4dv(index, v);
+    d_2_0_Core->f.VertexAttrib4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4bv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4bv(index, v);
+    d_2_0_Core->f.VertexAttrib4bv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4Nusv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4Nuiv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nubv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
 {
-    d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4Nsv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4Niv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4Niv(index, v);
+    d_2_0_Core->f.VertexAttrib4Niv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nbv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib3sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib3sv(index, v);
+    d_2_0_Core->f.VertexAttrib3sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
 {
-    d_2_0_Core->VertexAttrib3s(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib3fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib3fv(index, v);
+    d_2_0_Core->f.VertexAttrib3fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_2_0_Core->VertexAttrib3f(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib3dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib3dv(index, v);
+    d_2_0_Core->f.VertexAttrib3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_2_0_Core->VertexAttrib3d(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib2sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib2sv(index, v);
+    d_2_0_Core->f.VertexAttrib2sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
 {
-    d_2_0_Core->VertexAttrib2s(index, x, y);
+    d_2_0_Core->f.VertexAttrib2s(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib2fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib2fv(index, v);
+    d_2_0_Core->f.VertexAttrib2fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
 {
-    d_2_0_Core->VertexAttrib2f(index, x, y);
+    d_2_0_Core->f.VertexAttrib2f(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib2dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib2dv(index, v);
+    d_2_0_Core->f.VertexAttrib2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_2_0_Core->VertexAttrib2d(index, x, y);
+    d_2_0_Core->f.VertexAttrib2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib1sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib1sv(index, v);
+    d_2_0_Core->f.VertexAttrib1sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib1s(GLuint index, GLshort x)
 {
-    d_2_0_Core->VertexAttrib1s(index, x);
+    d_2_0_Core->f.VertexAttrib1s(index, x);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib1fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib1fv(index, v);
+    d_2_0_Core->f.VertexAttrib1fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib1f(GLuint index, GLfloat x)
 {
-    d_2_0_Core->VertexAttrib1f(index, x);
+    d_2_0_Core->f.VertexAttrib1f(index, x);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib1dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib1dv(index, v);
+    d_2_0_Core->f.VertexAttrib1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttrib1d(GLuint index, GLdouble x)
 {
-    d_2_0_Core->VertexAttrib1d(index, x);
+    d_2_0_Core->f.VertexAttrib1d(index, x);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glShaderSource(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Core::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Core::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetVertexAttribPointerv(GLuint index, GLenum pname, void * *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_4_4_Core::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_4_4_Core::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, shaders);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, shaders);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_4_4_Core::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_4_4_Core::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_4_4_Core::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_4_4_Core::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline void * QOpenGLFunctions_4_4_Core::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_4_4_Core::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Core::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Core::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_4_Core::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_4_4_Core::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI4usv(GLuint index, const GLushort *v)
 {
-    d_3_0_Core->VertexAttribI4usv(index, v);
+    d_3_0_Core->f.VertexAttribI4usv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
 {
-    d_3_0_Core->VertexAttribI4ubv(index, v);
+    d_3_0_Core->f.VertexAttribI4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI4sv(GLuint index, const GLshort *v)
 {
-    d_3_0_Core->VertexAttribI4sv(index, v);
+    d_3_0_Core->f.VertexAttribI4sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI4bv(GLuint index, const GLbyte *v)
 {
-    d_3_0_Core->VertexAttribI4bv(index, v);
+    d_3_0_Core->f.VertexAttribI4bv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI4uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI4uiv(index, v);
+    d_3_0_Core->f.VertexAttribI4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI3uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI3uiv(index, v);
+    d_3_0_Core->f.VertexAttribI3uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI2uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI2uiv(index, v);
+    d_3_0_Core->f.VertexAttribI2uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI1uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI1uiv(index, v);
+    d_3_0_Core->f.VertexAttribI1uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI4iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI4iv(index, v);
+    d_3_0_Core->f.VertexAttribI4iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI3iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI3iv(index, v);
+    d_3_0_Core->f.VertexAttribI3iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI2iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI2iv(index, v);
+    d_3_0_Core->f.VertexAttribI2iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI1iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI1iv(index, v);
+    d_3_0_Core->f.VertexAttribI1iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
 {
-    d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
 {
-    d_3_0_Core->VertexAttribI3ui(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
 {
-    d_3_0_Core->VertexAttribI2ui(index, x, y);
+    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI1ui(GLuint index, GLuint x)
 {
-    d_3_0_Core->VertexAttribI1ui(index, x);
+    d_3_0_Core->f.VertexAttribI1ui(index, x);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
 {
-    d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
 {
-    d_3_0_Core->VertexAttribI3i(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI2i(GLuint index, GLint x, GLint y)
 {
-    d_3_0_Core->VertexAttribI2i(index, x, y);
+    d_3_0_Core->f.VertexAttribI2i(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribI1i(GLuint index, GLint x)
 {
-    d_3_0_Core->VertexAttribI1i(index, x);
+    d_3_0_Core->f.VertexAttribI1i(index, x);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Core::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_4_4_Core::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_4_4_Core::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
 // OpenGL 3.2 core functions
 inline void QOpenGLFunctions_4_4_Core::glSampleMaski(GLuint maskNumber, GLbitfield mask)
 {
-    d_3_2_Core->SampleMaski(maskNumber, mask);
+    d_3_2_Core->f.SampleMaski(maskNumber, mask);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
 {
-    d_3_2_Core->GetMultisamplefv(pname, index, val);
+    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
-    d_3_2_Core->FramebufferTexture(target, attachment, texture, level);
+    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetBufferParameteri64v(target, pname, params);
+    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64i_v(target, index, data);
+    d_3_2_Core->f.GetInteger64i_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
-    d_3_2_Core->GetSynciv(sync, pname, bufSize, length, values);
+    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetInteger64v(GLenum pname, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64v(pname, data);
+    d_3_2_Core->f.GetInteger64v(pname, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    d_3_2_Core->WaitSync(sync, flags, timeout);
+    d_3_2_Core->f.WaitSync(sync, flags, timeout);
 }
 
 inline GLenum QOpenGLFunctions_4_4_Core::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    return d_3_2_Core->ClientWaitSync(sync, flags, timeout);
+    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDeleteSync(GLsync sync)
 {
-    d_3_2_Core->DeleteSync(sync);
+    d_3_2_Core->f.DeleteSync(sync);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Core::glIsSync(GLsync sync)
 {
-    return d_3_2_Core->IsSync(sync);
+    return d_3_2_Core->f.IsSync(sync);
 }
 
 inline GLsync QOpenGLFunctions_4_4_Core::glFenceSync(GLenum condition, GLbitfield flags)
 {
-    return d_3_2_Core->FenceSync(condition, flags);
+    return d_3_2_Core->f.FenceSync(condition, flags);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProvokingVertex(GLenum mode)
 {
-    d_3_2_Core->ProvokingVertex(mode);
+    d_3_2_Core->f.ProvokingVertex(mode);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex)
 {
-    d_3_2_Core->MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 }
 
 
 // OpenGL 3.3 core functions
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP4uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP4ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP3uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP3ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP2uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP2ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP1uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP1ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribDivisor(GLuint index, GLuint divisor)
 {
-    d_3_3_Core->VertexAttribDivisor(index, divisor);
+    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
 {
-    d_3_3_Core->GetQueryObjectui64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
 {
-    d_3_3_Core->GetQueryObjecti64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glQueryCounter(GLuint id, GLenum target)
 {
-    d_3_3_Core->QueryCounter(id, target);
+    d_3_3_Core->f.QueryCounter(id, target);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
 {
-    d_3_3_Core->GetSamplerParameterIuiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
 {
-    d_3_3_Core->GetSamplerParameterfv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameterIiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameteriv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
 {
-    d_3_3_Core->SamplerParameterIuiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameterIiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
 {
-    d_3_3_Core->SamplerParameterfv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
 {
-    d_3_3_Core->SamplerParameterf(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameteriv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
-    d_3_3_Core->SamplerParameteri(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindSampler(GLuint unit, GLuint sampler)
 {
-    d_3_3_Core->BindSampler(unit, sampler);
+    d_3_3_Core->f.BindSampler(unit, sampler);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Core::glIsSampler(GLuint sampler)
 {
-    return d_3_3_Core->IsSampler(sampler);
+    return d_3_3_Core->f.IsSampler(sampler);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDeleteSamplers(GLsizei count, const GLuint *samplers)
 {
-    d_3_3_Core->DeleteSamplers(count, samplers);
+    d_3_3_Core->f.DeleteSamplers(count, samplers);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGenSamplers(GLsizei count, GLuint *samplers)
 {
-    d_3_3_Core->GenSamplers(count, samplers);
+    d_3_3_Core->f.GenSamplers(count, samplers);
 }
 
 inline GLint QOpenGLFunctions_4_4_Core::glGetFragDataIndex(GLuint program, const GLchar *name)
 {
-    return d_3_3_Core->GetFragDataIndex(program, name);
+    return d_3_3_Core->f.GetFragDataIndex(program, name);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
 {
-    d_3_3_Core->BindFragDataLocationIndexed(program, colorNumber, index, name);
+    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
 }
 
 
 // OpenGL 4.0 core functions
 inline void QOpenGLFunctions_4_4_Core::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
 {
-    d_4_0_Core->GetQueryIndexediv(target, index, pname, params);
+    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glEndQueryIndexed(GLenum target, GLuint index)
 {
-    d_4_0_Core->EndQueryIndexed(target, index);
+    d_4_0_Core->f.EndQueryIndexed(target, index);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
 {
-    d_4_0_Core->BeginQueryIndexed(target, index, id);
+    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
 {
-    d_4_0_Core->DrawTransformFeedbackStream(mode, id, stream);
+    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawTransformFeedback(GLenum mode, GLuint id)
 {
-    d_4_0_Core->DrawTransformFeedback(mode, id);
+    d_4_0_Core->f.DrawTransformFeedback(mode, id);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glResumeTransformFeedback()
 {
-    d_4_0_Core->ResumeTransformFeedback();
+    d_4_0_Core->f.ResumeTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_4_Core::glPauseTransformFeedback()
 {
-    d_4_0_Core->PauseTransformFeedback();
+    d_4_0_Core->f.PauseTransformFeedback();
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Core::glIsTransformFeedback(GLuint id)
 {
-    return d_4_0_Core->IsTransformFeedback(id);
+    return d_4_0_Core->f.IsTransformFeedback(id);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
 {
-    d_4_0_Core->GenTransformFeedbacks(n, ids);
+    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
 {
-    d_4_0_Core->DeleteTransformFeedbacks(n, ids);
+    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindTransformFeedback(GLenum target, GLuint id)
 {
-    d_4_0_Core->BindTransformFeedback(target, id);
+    d_4_0_Core->f.BindTransformFeedback(target, id);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glPatchParameterfv(GLenum pname, const GLfloat *values)
 {
-    d_4_0_Core->PatchParameterfv(pname, values);
+    d_4_0_Core->f.PatchParameterfv(pname, values);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glPatchParameteri(GLenum pname, GLint value)
 {
-    d_4_0_Core->PatchParameteri(pname, value);
+    d_4_0_Core->f.PatchParameteri(pname, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetProgramStageiv(program, shadertype, pname, values);
+    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
 {
-    d_4_0_Core->GetUniformSubroutineuiv(shadertype, location, params);
+    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
 {
-    d_4_0_Core->UniformSubroutinesuiv(shadertype, count, indices);
+    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
+    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
 }
 
 inline GLuint QOpenGLFunctions_4_4_Core::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineIndex(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
 }
 
 inline GLint QOpenGLFunctions_4_4_Core::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineUniformLocation(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
 {
-    d_4_0_Core->GetUniformdv(program, location, params);
+    d_4_0_Core->f.GetUniformdv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform4dv(location, count, value);
+    d_4_0_Core->f.Uniform4dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform3dv(location, count, value);
+    d_4_0_Core->f.Uniform3dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform2dv(location, count, value);
+    d_4_0_Core->f.Uniform2dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform1dv(location, count, value);
+    d_4_0_Core->f.Uniform1dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_0_Core->Uniform4d(location, x, y, z, w);
+    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_0_Core->Uniform3d(location, x, y, z);
+    d_4_0_Core->f.Uniform3d(location, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform2d(GLint location, GLdouble x, GLdouble y)
 {
-    d_4_0_Core->Uniform2d(location, x, y);
+    d_4_0_Core->f.Uniform2d(location, x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUniform1d(GLint location, GLdouble x)
 {
-    d_4_0_Core->Uniform1d(location, x);
+    d_4_0_Core->f.Uniform1d(location, x);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
 {
-    d_4_0_Core->DrawElementsIndirect(mode, type, indirect);
+    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawArraysIndirect(GLenum mode, const void *indirect)
 {
-    d_4_0_Core->DrawArraysIndirect(mode, indirect);
+    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-    d_4_0_Core->BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
 {
-    d_4_0_Core->BlendFunci(buf, src, dst);
+    d_4_0_Core->f.BlendFunci(buf, src, dst);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
 {
-    d_4_0_Core->BlendEquationSeparatei(buf, modeRGB, modeAlpha);
+    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBlendEquationi(GLuint buf, GLenum mode)
 {
-    d_4_0_Core->BlendEquationi(buf, mode);
+    d_4_0_Core->f.BlendEquationi(buf, mode);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glMinSampleShading(GLfloat value)
 {
-    d_4_0_Core->MinSampleShading(value);
+    d_4_0_Core->f.MinSampleShading(value);
 }
 
 
 // OpenGL 4.1 core functions
 inline void QOpenGLFunctions_4_4_Core::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
 {
-    d_4_1_Core->GetDoublei_v(target, index, data);
+    d_4_1_Core->f.GetDoublei_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
 {
-    d_4_1_Core->GetFloati_v(target, index, data);
+    d_4_1_Core->f.GetFloati_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
 {
-    d_4_1_Core->DepthRangeIndexed(index, n, f);
+    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
 {
-    d_4_1_Core->DepthRangeArrayv(first, count, v);
+    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glScissorIndexedv(GLuint index, const GLint *v)
 {
-    d_4_1_Core->ScissorIndexedv(index, v);
+    d_4_1_Core->f.ScissorIndexedv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
 {
-    d_4_1_Core->ScissorIndexed(index, left, bottom, width, height);
+    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
 {
-    d_4_1_Core->ScissorArrayv(first, count, v);
+    d_4_1_Core->f.ScissorArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glViewportIndexedfv(GLuint index, const GLfloat *v)
 {
-    d_4_1_Core->ViewportIndexedfv(index, v);
+    d_4_1_Core->f.ViewportIndexedfv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
 {
-    d_4_1_Core->ViewportIndexedf(index, x, y, w, h);
+    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
 {
-    d_4_1_Core->ViewportArrayv(first, count, v);
+    d_4_1_Core->f.ViewportArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_4_1_Core->GetVertexAttribLdv(index, pname, params);
+    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
-    d_4_1_Core->VertexAttribLPointer(index, size, type, stride, pointer);
+    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribL4dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL4dv(index, v);
+    d_4_1_Core->f.VertexAttribL4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribL3dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL3dv(index, v);
+    d_4_1_Core->f.VertexAttribL3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribL2dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL2dv(index, v);
+    d_4_1_Core->f.VertexAttribL2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribL1dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL1dv(index, v);
+    d_4_1_Core->f.VertexAttribL1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_1_Core->VertexAttribL4d(index, x, y, z, w);
+    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_1_Core->VertexAttribL3d(index, x, y, z);
+    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_4_1_Core->VertexAttribL2d(index, x, y);
+    d_4_1_Core->f.VertexAttribL2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribL1d(GLuint index, GLdouble x)
 {
-    d_4_1_Core->VertexAttribL1d(index, x);
+    d_4_1_Core->f.VertexAttribL1d(index, x);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_4_1_Core->GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glValidateProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->ValidateProgramPipeline(pipeline);
+    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform4uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_4_1_Core->ProgramUniform4ui(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform4dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
 {
-    d_4_1_Core->ProgramUniform4d(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform4fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_4_1_Core->ProgramUniform4f(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform4iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_4_1_Core->ProgramUniform4i(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform3uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_4_1_Core->ProgramUniform3ui(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform3dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
 {
-    d_4_1_Core->ProgramUniform3d(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform3fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_4_1_Core->ProgramUniform3f(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform3iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_4_1_Core->ProgramUniform3i(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform2uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
 {
-    d_4_1_Core->ProgramUniform2ui(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform2dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
 {
-    d_4_1_Core->ProgramUniform2d(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform2fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
 {
-    d_4_1_Core->ProgramUniform2f(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform2iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
 {
-    d_4_1_Core->ProgramUniform2i(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform1uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
 {
-    d_4_1_Core->ProgramUniform1ui(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform1dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
 {
-    d_4_1_Core->ProgramUniform1d(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform1fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
 {
-    d_4_1_Core->ProgramUniform1f(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform1iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramUniform1i(GLuint program, GLint location, GLint v0)
 {
-    d_4_1_Core->ProgramUniform1i(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
 {
-    d_4_1_Core->GetProgramPipelineiv(pipeline, pname, params);
+    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_4_Core::glIsProgramPipeline(GLuint pipeline)
 {
-    return d_4_1_Core->IsProgramPipeline(pipeline);
+    return d_4_1_Core->f.IsProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
 {
-    d_4_1_Core->GenProgramPipelines(n, pipelines);
+    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
 {
-    d_4_1_Core->DeleteProgramPipelines(n, pipelines);
+    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->BindProgramPipeline(pipeline);
+    d_4_1_Core->f.BindProgramPipeline(pipeline);
 }
 
 inline GLuint QOpenGLFunctions_4_4_Core::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
 {
-    return d_4_1_Core->CreateShaderProgramv(type, count, strings);
+    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glActiveShaderProgram(GLuint pipeline, GLuint program)
 {
-    d_4_1_Core->ActiveShaderProgram(pipeline, program);
+    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
 {
-    d_4_1_Core->UseProgramStages(pipeline, stages, program);
+    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramParameteri(GLuint program, GLenum pname, GLint value)
 {
-    d_4_1_Core->ProgramParameteri(program, pname, value);
+    d_4_1_Core->f.ProgramParameteri(program, pname, value);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
 {
-    d_4_1_Core->ProgramBinary(program, binaryFormat, binary, length);
+    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)
 {
-    d_4_1_Core->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
+    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glClearDepthf(GLfloat dd)
 {
-    d_4_1_Core->ClearDepthf(dd);
+    d_4_1_Core->f.ClearDepthf(dd);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDepthRangef(GLfloat n, GLfloat f)
 {
-    d_4_1_Core->DepthRangef(n, f);
+    d_4_1_Core->f.DepthRangef(n, f);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
 {
-    d_4_1_Core->GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length)
 {
-    d_4_1_Core->ShaderBinary(count, shaders, binaryformat, binary, length);
+    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glReleaseShaderCompiler()
 {
-    d_4_1_Core->ReleaseShaderCompiler();
+    d_4_1_Core->f.ReleaseShaderCompiler();
 }
 
 
 // OpenGL 4.2 core functions
 inline void QOpenGLFunctions_4_4_Core::glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
 {
-    d_4_2_Core->DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
+    d_4_2_Core->f.DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
 {
-    d_4_2_Core->DrawTransformFeedbackInstanced(mode, id, instancecount);
+    d_4_2_Core->f.DrawTransformFeedbackInstanced(mode, id, instancecount);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
-    d_4_2_Core->TexStorage3D(target, levels, internalformat, width, height, depth);
+    d_4_2_Core->f.TexStorage3D(target, levels, internalformat, width, height, depth);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_4_2_Core->TexStorage2D(target, levels, internalformat, width, height);
+    d_4_2_Core->f.TexStorage2D(target, levels, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
 {
-    d_4_2_Core->TexStorage1D(target, levels, internalformat, width);
+    d_4_2_Core->f.TexStorage1D(target, levels, internalformat, width);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glMemoryBarrier(GLbitfield barriers)
 {
-    d_4_2_Core->MemoryBarrier(barriers);
+    d_4_2_Core->f.MemoryBarrier(barriers);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
 {
-    d_4_2_Core->BindImageTexture(unit, texture, level, layered, layer, access, format);
+    d_4_2_Core->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
 {
-    d_4_2_Core->GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
+    d_4_2_Core->f.GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
 {
-    d_4_2_Core->GetInternalformativ(target, internalformat, pname, bufSize, params);
+    d_4_2_Core->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
 {
-    d_4_2_Core->DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
+    d_4_2_Core->f.DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
 {
-    d_4_2_Core->DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
+    d_4_2_Core->f.DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
 {
-    d_4_2_Core->DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
+    d_4_2_Core->f.DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
 }
 
 
 // OpenGL 4.3 core functions
 inline void QOpenGLFunctions_4_4_Core::glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
 {
-    d_4_3_Core->GetObjectPtrLabel(ptr, bufSize, length, label);
+    d_4_3_Core->f.GetObjectPtrLabel(ptr, bufSize, length, label);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label)
 {
-    d_4_3_Core->ObjectPtrLabel(ptr, length, label);
+    d_4_3_Core->f.ObjectPtrLabel(ptr, length, label);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
 {
-    d_4_3_Core->GetObjectLabel(identifier, name, bufSize, length, label);
+    d_4_3_Core->f.GetObjectLabel(identifier, name, bufSize, length, label);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
 {
-    d_4_3_Core->ObjectLabel(identifier, name, length, label);
+    d_4_3_Core->f.ObjectLabel(identifier, name, length, label);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glPopDebugGroup()
 {
-    d_4_3_Core->PopDebugGroup();
+    d_4_3_Core->f.PopDebugGroup();
 }
 
 inline void QOpenGLFunctions_4_4_Core::glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message)
 {
-    d_4_3_Core->PushDebugGroup(source, id, length, message);
+    d_4_3_Core->f.PushDebugGroup(source, id, length, message);
 }
 
 inline GLuint QOpenGLFunctions_4_4_Core::glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
 {
-    return d_4_3_Core->GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
+    return d_4_3_Core->f.GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
 {
-    d_4_3_Core->DebugMessageCallback(callback, userParam);
+    d_4_3_Core->f.DebugMessageCallback(callback, userParam);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
 {
-    d_4_3_Core->DebugMessageInsert(source, type, id, severity, length, buf);
+    d_4_3_Core->f.DebugMessageInsert(source, type, id, severity, length, buf);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)
 {
-    d_4_3_Core->DebugMessageControl(source, type, severity, count, ids, enabled);
+    d_4_3_Core->f.DebugMessageControl(source, type, severity, count, ids, enabled);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
 {
-    d_4_3_Core->VertexBindingDivisor(bindingindex, divisor);
+    d_4_3_Core->f.VertexBindingDivisor(bindingindex, divisor);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
 {
-    d_4_3_Core->VertexAttribBinding(attribindex, bindingindex);
+    d_4_3_Core->f.VertexAttribBinding(attribindex, bindingindex);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribLFormat(attribindex, size, type, relativeoffset);
+    d_4_3_Core->f.VertexAttribLFormat(attribindex, size, type, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribIFormat(attribindex, size, type, relativeoffset);
+    d_4_3_Core->f.VertexAttribIFormat(attribindex, size, type, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
+    d_4_3_Core->f.VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
 {
-    d_4_3_Core->BindVertexBuffer(bindingindex, buffer, offset, stride);
+    d_4_3_Core->f.BindVertexBuffer(bindingindex, buffer, offset, stride);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
 {
-    d_4_3_Core->TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
+    d_4_3_Core->f.TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_4_3_Core->TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_4_3_Core->f.TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_4_3_Core->TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_4_3_Core->f.TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_4_3_Core->TexBufferRange(target, internalformat, buffer, offset, size);
+    d_4_3_Core->f.TexBufferRange(target, internalformat, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
 {
-    d_4_3_Core->ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
+    d_4_3_Core->f.ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
 }
 
 inline GLint QOpenGLFunctions_4_4_Core::glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceLocationIndex(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceLocationIndex(program, programInterface, name);
 }
 
 inline GLint QOpenGLFunctions_4_4_Core::glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceLocation(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceLocation(program, programInterface, name);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
 {
-    d_4_3_Core->GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
+    d_4_3_Core->f.GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
 {
-    d_4_3_Core->GetProgramResourceName(program, programInterface, index, bufSize, length, name);
+    d_4_3_Core->f.GetProgramResourceName(program, programInterface, index, bufSize, length, name);
 }
 
 inline GLuint QOpenGLFunctions_4_4_Core::glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceIndex(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceIndex(program, programInterface, name);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params)
 {
-    d_4_3_Core->GetProgramInterfaceiv(program, programInterface, pname, params);
+    d_4_3_Core->f.GetProgramInterfaceiv(program, programInterface, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
 {
-    d_4_3_Core->MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
+    d_4_3_Core->f.MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
 {
-    d_4_3_Core->MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
+    d_4_3_Core->f.MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_4_3_Core->InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
+    d_4_3_Core->f.InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
 {
-    d_4_3_Core->InvalidateFramebuffer(target, numAttachments, attachments);
+    d_4_3_Core->f.InvalidateFramebuffer(target, numAttachments, attachments);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glInvalidateBufferData(GLuint buffer)
 {
-    d_4_3_Core->InvalidateBufferData(buffer);
+    d_4_3_Core->f.InvalidateBufferData(buffer);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
 {
-    d_4_3_Core->InvalidateBufferSubData(buffer, offset, length);
+    d_4_3_Core->f.InvalidateBufferSubData(buffer, offset, length);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glInvalidateTexImage(GLuint texture, GLint level)
 {
-    d_4_3_Core->InvalidateTexImage(texture, level);
+    d_4_3_Core->f.InvalidateTexImage(texture, level);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
 {
-    d_4_3_Core->InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
+    d_4_3_Core->f.InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)
 {
-    d_4_3_Core->GetInternalformati64v(target, internalformat, pname, bufSize, params);
+    d_4_3_Core->f.GetInternalformati64v(target, internalformat, pname, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_4_3_Core->GetFramebufferParameteriv(target, pname, params);
+    d_4_3_Core->f.GetFramebufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_4_3_Core->FramebufferParameteri(target, pname, param);
+    d_4_3_Core->f.FramebufferParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
 {
-    d_4_3_Core->CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
+    d_4_3_Core->f.CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDispatchComputeIndirect(GLintptr indirect)
 {
-    d_4_3_Core->DispatchComputeIndirect(indirect);
+    d_4_3_Core->f.DispatchComputeIndirect(indirect);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
 {
-    d_4_3_Core->DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
+    d_4_3_Core->f.DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
 {
-    d_4_3_Core->ClearBufferSubData(target, internalformat, offset, size, format, type, data);
+    d_4_3_Core->f.ClearBufferSubData(target, internalformat, offset, size, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)
 {
-    d_4_3_Core->ClearBufferData(target, internalformat, format, type, data);
+    d_4_3_Core->f.ClearBufferData(target, internalformat, format, type, data);
 }
 
 
 // OpenGL 4.4 core functions
 inline void QOpenGLFunctions_4_4_Core::glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
 {
-    d_4_4_Core->BindVertexBuffers(first, count, buffers, offsets, strides);
+    d_4_4_Core->f.BindVertexBuffers(first, count, buffers, offsets, strides);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures)
 {
-    d_4_4_Core->BindImageTextures(first, count, textures);
+    d_4_4_Core->f.BindImageTextures(first, count, textures);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers)
 {
-    d_4_4_Core->BindSamplers(first, count, samplers);
+    d_4_4_Core->f.BindSamplers(first, count, samplers);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindTextures(GLuint first, GLsizei count, const GLuint *textures)
 {
-    d_4_4_Core->BindTextures(first, count, textures);
+    d_4_4_Core->f.BindTextures(first, count, textures);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes)
 {
-    d_4_4_Core->BindBuffersRange(target, first, count, buffers, offsets, sizes);
+    d_4_4_Core->f.BindBuffersRange(target, first, count, buffers, offsets, sizes);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers)
 {
-    d_4_4_Core->BindBuffersBase(target, first, count, buffers);
+    d_4_4_Core->f.BindBuffersBase(target, first, count, buffers);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data)
 {
-    d_4_4_Core->ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
+    d_4_4_Core->f.ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data)
 {
-    d_4_4_Core->ClearTexImage(texture, level, format, type, data);
+    d_4_4_Core->f.ClearTexImage(texture, level, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_4_Core::glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)
 {
-    d_4_4_Core->BufferStorage(target, size, data, flags);
+    d_4_4_Core->f.BufferStorage(target, size, data, flags);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_4_5_compatibility.cpp b/src/gui/opengl/qopenglfunctions_4_5_compatibility.cpp
index 99601522568..81ee8559a51 100644
--- a/src/gui/opengl/qopenglfunctions_4_5_compatibility.cpp
+++ b/src/gui/opengl/qopenglfunctions_4_5_compatibility.cpp
@@ -3,7 +3,7 @@
 ** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
 ** Contact: https://www.qt.io/licensing/
 **
-** This file is part of the QtWidgets module of the Qt Toolkit.
+** This file is part of the QtGui module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** Commercial License Usage
@@ -97,106 +97,81 @@ QOpenGLFunctions_4_5_Compatibility::QOpenGLFunctions_4_5_Compatibility()
 
 QOpenGLFunctions_4_5_Compatibility::~QOpenGLFunctions_4_5_Compatibility()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
-    if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        delete d_3_2_Core;
-    }
-    if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        delete d_3_3_Core;
-    }
-    if (d_4_0_Core && !d_4_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_0_Core->context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        delete d_4_0_Core;
-    }
-    if (d_4_1_Core && !d_4_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_1_Core->context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        delete d_4_1_Core;
-    }
-    if (d_4_2_Core && !d_4_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_2_Core->context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        delete d_4_2_Core;
-    }
-    if (d_4_3_Core && !d_4_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_3_Core->context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        delete d_4_3_Core;
-    }
-    if (d_4_4_Core && !d_4_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_4_Core->context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
-        delete d_4_4_Core;
-    }
-    if (d_4_5_Core && !d_4_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_5_Core->context, QOpenGLFunctions_4_5_CoreBackend::versionStatus());
-        delete d_4_5_Core;
-    }
-    if (d_1_0_Deprecated && !d_1_0_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Deprecated->context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        delete d_1_0_Deprecated;
-    }
-    if (d_1_1_Deprecated && !d_1_1_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Deprecated->context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        delete d_1_1_Deprecated;
-    }
-    if (d_1_2_Deprecated && !d_1_2_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Deprecated->context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        delete d_1_2_Deprecated;
-    }
-    if (d_1_3_Deprecated && !d_1_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Deprecated->context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        delete d_1_3_Deprecated;
-    }
-    if (d_1_4_Deprecated && !d_1_4_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Deprecated->context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        delete d_1_4_Deprecated;
-    }
-    if (d_3_3_Deprecated && !d_3_3_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Deprecated->context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        delete d_3_3_Deprecated;
-    }
-    if (d_4_5_Deprecated && !d_4_5_Deprecated->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_5_Deprecated->context, QOpenGLFunctions_4_5_DeprecatedBackend::versionStatus());
-        delete d_4_5_Deprecated;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
+    if (d_3_2_Core)
+        d_3_2_Core->refs.deref();
+    Q_ASSERT(d_3_2_Core->refs.load());
+    if (d_3_3_Core)
+        d_3_3_Core->refs.deref();
+    Q_ASSERT(d_3_3_Core->refs.load());
+    if (d_4_0_Core)
+        d_4_0_Core->refs.deref();
+    Q_ASSERT(d_4_0_Core->refs.load());
+    if (d_4_1_Core)
+        d_4_1_Core->refs.deref();
+    Q_ASSERT(d_4_1_Core->refs.load());
+    if (d_4_2_Core)
+        d_4_2_Core->refs.deref();
+    Q_ASSERT(d_4_2_Core->refs.load());
+    if (d_4_3_Core)
+        d_4_3_Core->refs.deref();
+    Q_ASSERT(d_4_3_Core->refs.load());
+    if (d_4_4_Core)
+        d_4_4_Core->refs.deref();
+    Q_ASSERT(d_4_4_Core->refs.load());
+    if (d_4_5_Core)
+        d_4_5_Core->refs.deref();
+    Q_ASSERT(d_4_5_Core->refs.load());
+    if (d_1_0_Deprecated)
+        d_1_0_Deprecated->refs.deref();
+    Q_ASSERT(d_1_0_Deprecated->refs.load());
+    if (d_1_1_Deprecated)
+        d_1_1_Deprecated->refs.deref();
+    Q_ASSERT(d_1_1_Deprecated->refs.load());
+    if (d_1_2_Deprecated)
+        d_1_2_Deprecated->refs.deref();
+    Q_ASSERT(d_1_2_Deprecated->refs.load());
+    if (d_1_3_Deprecated)
+        d_1_3_Deprecated->refs.deref();
+    Q_ASSERT(d_1_3_Deprecated->refs.load());
+    if (d_1_4_Deprecated)
+        d_1_4_Deprecated->refs.deref();
+    Q_ASSERT(d_1_4_Deprecated->refs.load());
+    if (d_3_3_Deprecated)
+        d_3_3_Deprecated->refs.deref();
+    Q_ASSERT(d_3_3_Deprecated->refs.load());
+    if (d_4_5_Deprecated)
+        d_4_5_Deprecated->refs.deref();
+    Q_ASSERT(d_4_5_Deprecated->refs.load());
 }
 
 bool QOpenGLFunctions_4_5_Compatibility::initializeOpenGLFunctions()
@@ -215,202 +190,102 @@ bool QOpenGLFunctions_4_5_Compatibility::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
-        }
         d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
-        }
         d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus(), d);
-        }
         d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus(), d);
-        }
         d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus(), d);
-        }
         d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus(), d);
-        }
         d_4_3_Core = static_cast<QOpenGLFunctions_4_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus(), d);
-        }
         d_4_4_Core = static_cast<QOpenGLFunctions_4_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_5_CoreBackend::versionStatus(), d);
-        }
         d_4_5_Core = static_cast<QOpenGLFunctions_4_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_0_Deprecated = static_cast<QOpenGLFunctions_1_0_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_1_Deprecated = static_cast<QOpenGLFunctions_1_1_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_2_Deprecated = static_cast<QOpenGLFunctions_1_2_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_3_Deprecated = static_cast<QOpenGLFunctions_1_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus(), d);
-        }
         d_1_4_Deprecated = static_cast<QOpenGLFunctions_1_4_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus(), d);
-        }
         d_3_3_Deprecated = static_cast<QOpenGLFunctions_3_3_DeprecatedBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_5_DeprecatedBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_5_DeprecatedBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_5_DeprecatedBackend::versionStatus(), d);
-        }
         d_4_5_Deprecated = static_cast<QOpenGLFunctions_4_5_DeprecatedBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_4_5_compatibility.h b/src/gui/opengl/qopenglfunctions_4_5_compatibility.h
index e7c74d2dd81..1c50dafd65a 100644
--- a/src/gui/opengl/qopenglfunctions_4_5_compatibility.h
+++ b/src/gui/opengl/qopenglfunctions_4_5_compatibility.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtWidgets module of the Qt Toolkit.
@@ -1246,5196 +1247,5196 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_4_5_Compatibility::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_5_Compatibility::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetIntegerv(GLenum pname, GLint *data)
 {
-    d_1_0_Core->GetIntegerv(pname, data);
+    d_1_0_Core->f.GetIntegerv(pname, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetFloatv(GLenum pname, GLfloat *data)
 {
-    d_1_0_Core->GetFloatv(pname, data);
+    d_1_0_Core->f.GetFloatv(pname, data);
 }
 
 inline GLenum QOpenGLFunctions_4_5_Compatibility::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetDoublev(GLenum pname, GLdouble *data)
 {
-    d_1_0_Core->GetDoublev(pname, data);
+    d_1_0_Core->f.GetDoublev(pname, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetBooleanv(GLenum pname, GLboolean *data)
 {
-    d_1_0_Core->GetBooleanv(pname, data);
+    d_1_0_Core->f.GetBooleanv(pname, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glReadBuffer(GLenum src)
 {
-    d_1_0_Core->ReadBuffer(src);
+    d_1_0_Core->f.ReadBuffer(src);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawBuffer(GLenum buf)
 {
-    d_1_0_Core->DrawBuffer(buf);
+    d_1_0_Core->f.DrawBuffer(buf);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_4_5_Compatibility::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_4_5_Compatibility::glGetCompressedTexImage(GLenum target, GLint level, void *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_4_5_Compatibility::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_4_5_Compatibility::glGetBufferPointerv(GLenum target, GLenum pname, void * *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline void * QOpenGLFunctions_4_5_Compatibility::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4usv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4usv(index, v);
+    d_2_0_Core->f.VertexAttrib4usv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4uiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4uiv(index, v);
+    d_2_0_Core->f.VertexAttrib4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4ubv(index, v);
+    d_2_0_Core->f.VertexAttrib4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4sv(index, v);
+    d_2_0_Core->f.VertexAttrib4sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4iv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4iv(index, v);
+    d_2_0_Core->f.VertexAttrib4iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib4fv(index, v);
+    d_2_0_Core->f.VertexAttrib4fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib4dv(index, v);
+    d_2_0_Core->f.VertexAttrib4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4bv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4bv(index, v);
+    d_2_0_Core->f.VertexAttrib4bv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4Nusv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4Nuiv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nubv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
 {
-    d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4Nsv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4Niv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4Niv(index, v);
+    d_2_0_Core->f.VertexAttrib4Niv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nbv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib3sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib3sv(index, v);
+    d_2_0_Core->f.VertexAttrib3sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
 {
-    d_2_0_Core->VertexAttrib3s(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib3fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib3fv(index, v);
+    d_2_0_Core->f.VertexAttrib3fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_2_0_Core->VertexAttrib3f(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib3dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib3dv(index, v);
+    d_2_0_Core->f.VertexAttrib3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_2_0_Core->VertexAttrib3d(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib2sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib2sv(index, v);
+    d_2_0_Core->f.VertexAttrib2sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
 {
-    d_2_0_Core->VertexAttrib2s(index, x, y);
+    d_2_0_Core->f.VertexAttrib2s(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib2fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib2fv(index, v);
+    d_2_0_Core->f.VertexAttrib2fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
 {
-    d_2_0_Core->VertexAttrib2f(index, x, y);
+    d_2_0_Core->f.VertexAttrib2f(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib2dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib2dv(index, v);
+    d_2_0_Core->f.VertexAttrib2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_2_0_Core->VertexAttrib2d(index, x, y);
+    d_2_0_Core->f.VertexAttrib2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib1sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib1sv(index, v);
+    d_2_0_Core->f.VertexAttrib1sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib1s(GLuint index, GLshort x)
 {
-    d_2_0_Core->VertexAttrib1s(index, x);
+    d_2_0_Core->f.VertexAttrib1s(index, x);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib1fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib1fv(index, v);
+    d_2_0_Core->f.VertexAttrib1fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib1f(GLuint index, GLfloat x)
 {
-    d_2_0_Core->VertexAttrib1f(index, x);
+    d_2_0_Core->f.VertexAttrib1f(index, x);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib1dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib1dv(index, v);
+    d_2_0_Core->f.VertexAttrib1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttrib1d(GLuint index, GLdouble x)
 {
-    d_2_0_Core->VertexAttrib1d(index, x);
+    d_2_0_Core->f.VertexAttrib1d(index, x);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glShaderSource(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexAttribPointerv(GLuint index, GLenum pname, void * *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_4_5_Compatibility::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_4_5_Compatibility::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, shaders);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, shaders);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_4_5_Compatibility::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_4_5_Compatibility::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline void * QOpenGLFunctions_4_5_Compatibility::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_4_5_Compatibility::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_5_Compatibility::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_4_5_Compatibility::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI4usv(GLuint index, const GLushort *v)
 {
-    d_3_0_Core->VertexAttribI4usv(index, v);
+    d_3_0_Core->f.VertexAttribI4usv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
 {
-    d_3_0_Core->VertexAttribI4ubv(index, v);
+    d_3_0_Core->f.VertexAttribI4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI4sv(GLuint index, const GLshort *v)
 {
-    d_3_0_Core->VertexAttribI4sv(index, v);
+    d_3_0_Core->f.VertexAttribI4sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI4bv(GLuint index, const GLbyte *v)
 {
-    d_3_0_Core->VertexAttribI4bv(index, v);
+    d_3_0_Core->f.VertexAttribI4bv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI4uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI4uiv(index, v);
+    d_3_0_Core->f.VertexAttribI4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI3uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI3uiv(index, v);
+    d_3_0_Core->f.VertexAttribI3uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI2uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI2uiv(index, v);
+    d_3_0_Core->f.VertexAttribI2uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI1uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI1uiv(index, v);
+    d_3_0_Core->f.VertexAttribI1uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI4iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI4iv(index, v);
+    d_3_0_Core->f.VertexAttribI4iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI3iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI3iv(index, v);
+    d_3_0_Core->f.VertexAttribI3iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI2iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI2iv(index, v);
+    d_3_0_Core->f.VertexAttribI2iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI1iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI1iv(index, v);
+    d_3_0_Core->f.VertexAttribI1iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
 {
-    d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
 {
-    d_3_0_Core->VertexAttribI3ui(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
 {
-    d_3_0_Core->VertexAttribI2ui(index, x, y);
+    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI1ui(GLuint index, GLuint x)
 {
-    d_3_0_Core->VertexAttribI1ui(index, x);
+    d_3_0_Core->f.VertexAttribI1ui(index, x);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
 {
-    d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
 {
-    d_3_0_Core->VertexAttribI3i(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI2i(GLuint index, GLint x, GLint y)
 {
-    d_3_0_Core->VertexAttribI2i(index, x, y);
+    d_3_0_Core->f.VertexAttribI2i(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribI1i(GLuint index, GLint x)
 {
-    d_3_0_Core->VertexAttribI1i(index, x);
+    d_3_0_Core->f.VertexAttribI1i(index, x);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_4_5_Compatibility::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
 // OpenGL 3.2 core functions
 inline void QOpenGLFunctions_4_5_Compatibility::glSampleMaski(GLuint maskNumber, GLbitfield mask)
 {
-    d_3_2_Core->SampleMaski(maskNumber, mask);
+    d_3_2_Core->f.SampleMaski(maskNumber, mask);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
 {
-    d_3_2_Core->GetMultisamplefv(pname, index, val);
+    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
-    d_3_2_Core->FramebufferTexture(target, attachment, texture, level);
+    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetBufferParameteri64v(target, pname, params);
+    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64i_v(target, index, data);
+    d_3_2_Core->f.GetInteger64i_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
-    d_3_2_Core->GetSynciv(sync, pname, bufSize, length, values);
+    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetInteger64v(GLenum pname, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64v(pname, data);
+    d_3_2_Core->f.GetInteger64v(pname, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    d_3_2_Core->WaitSync(sync, flags, timeout);
+    d_3_2_Core->f.WaitSync(sync, flags, timeout);
 }
 
 inline GLenum QOpenGLFunctions_4_5_Compatibility::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    return d_3_2_Core->ClientWaitSync(sync, flags, timeout);
+    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDeleteSync(GLsync sync)
 {
-    d_3_2_Core->DeleteSync(sync);
+    d_3_2_Core->f.DeleteSync(sync);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsSync(GLsync sync)
 {
-    return d_3_2_Core->IsSync(sync);
+    return d_3_2_Core->f.IsSync(sync);
 }
 
 inline GLsync QOpenGLFunctions_4_5_Compatibility::glFenceSync(GLenum condition, GLbitfield flags)
 {
-    return d_3_2_Core->FenceSync(condition, flags);
+    return d_3_2_Core->f.FenceSync(condition, flags);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProvokingVertex(GLenum mode)
 {
-    d_3_2_Core->ProvokingVertex(mode);
+    d_3_2_Core->f.ProvokingVertex(mode);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex)
 {
-    d_3_2_Core->MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 }
 
 
 // OpenGL 3.3 core functions
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP4uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP4ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP3uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP3ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP2uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP2ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP1uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP1ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribDivisor(GLuint index, GLuint divisor)
 {
-    d_3_3_Core->VertexAttribDivisor(index, divisor);
+    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
 {
-    d_3_3_Core->GetQueryObjectui64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
 {
-    d_3_3_Core->GetQueryObjecti64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glQueryCounter(GLuint id, GLenum target)
 {
-    d_3_3_Core->QueryCounter(id, target);
+    d_3_3_Core->f.QueryCounter(id, target);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
 {
-    d_3_3_Core->GetSamplerParameterIuiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
 {
-    d_3_3_Core->GetSamplerParameterfv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameterIiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameteriv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
 {
-    d_3_3_Core->SamplerParameterIuiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameterIiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
 {
-    d_3_3_Core->SamplerParameterfv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
 {
-    d_3_3_Core->SamplerParameterf(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameteriv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
-    d_3_3_Core->SamplerParameteri(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindSampler(GLuint unit, GLuint sampler)
 {
-    d_3_3_Core->BindSampler(unit, sampler);
+    d_3_3_Core->f.BindSampler(unit, sampler);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsSampler(GLuint sampler)
 {
-    return d_3_3_Core->IsSampler(sampler);
+    return d_3_3_Core->f.IsSampler(sampler);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDeleteSamplers(GLsizei count, const GLuint *samplers)
 {
-    d_3_3_Core->DeleteSamplers(count, samplers);
+    d_3_3_Core->f.DeleteSamplers(count, samplers);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGenSamplers(GLsizei count, GLuint *samplers)
 {
-    d_3_3_Core->GenSamplers(count, samplers);
+    d_3_3_Core->f.GenSamplers(count, samplers);
 }
 
 inline GLint QOpenGLFunctions_4_5_Compatibility::glGetFragDataIndex(GLuint program, const GLchar *name)
 {
-    return d_3_3_Core->GetFragDataIndex(program, name);
+    return d_3_3_Core->f.GetFragDataIndex(program, name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
 {
-    d_3_3_Core->BindFragDataLocationIndexed(program, colorNumber, index, name);
+    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
 }
 
 
 // OpenGL 4.0 core functions
 inline void QOpenGLFunctions_4_5_Compatibility::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
 {
-    d_4_0_Core->GetQueryIndexediv(target, index, pname, params);
+    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEndQueryIndexed(GLenum target, GLuint index)
 {
-    d_4_0_Core->EndQueryIndexed(target, index);
+    d_4_0_Core->f.EndQueryIndexed(target, index);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
 {
-    d_4_0_Core->BeginQueryIndexed(target, index, id);
+    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
 {
-    d_4_0_Core->DrawTransformFeedbackStream(mode, id, stream);
+    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawTransformFeedback(GLenum mode, GLuint id)
 {
-    d_4_0_Core->DrawTransformFeedback(mode, id);
+    d_4_0_Core->f.DrawTransformFeedback(mode, id);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glResumeTransformFeedback()
 {
-    d_4_0_Core->ResumeTransformFeedback();
+    d_4_0_Core->f.ResumeTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPauseTransformFeedback()
 {
-    d_4_0_Core->PauseTransformFeedback();
+    d_4_0_Core->f.PauseTransformFeedback();
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsTransformFeedback(GLuint id)
 {
-    return d_4_0_Core->IsTransformFeedback(id);
+    return d_4_0_Core->f.IsTransformFeedback(id);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
 {
-    d_4_0_Core->GenTransformFeedbacks(n, ids);
+    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
 {
-    d_4_0_Core->DeleteTransformFeedbacks(n, ids);
+    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindTransformFeedback(GLenum target, GLuint id)
 {
-    d_4_0_Core->BindTransformFeedback(target, id);
+    d_4_0_Core->f.BindTransformFeedback(target, id);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPatchParameterfv(GLenum pname, const GLfloat *values)
 {
-    d_4_0_Core->PatchParameterfv(pname, values);
+    d_4_0_Core->f.PatchParameterfv(pname, values);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPatchParameteri(GLenum pname, GLint value)
 {
-    d_4_0_Core->PatchParameteri(pname, value);
+    d_4_0_Core->f.PatchParameteri(pname, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetProgramStageiv(program, shadertype, pname, values);
+    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
 {
-    d_4_0_Core->GetUniformSubroutineuiv(shadertype, location, params);
+    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
 {
-    d_4_0_Core->UniformSubroutinesuiv(shadertype, count, indices);
+    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
+    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
 }
 
 inline GLuint QOpenGLFunctions_4_5_Compatibility::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineIndex(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
 }
 
 inline GLint QOpenGLFunctions_4_5_Compatibility::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineUniformLocation(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
 {
-    d_4_0_Core->GetUniformdv(program, location, params);
+    d_4_0_Core->f.GetUniformdv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform4dv(location, count, value);
+    d_4_0_Core->f.Uniform4dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform3dv(location, count, value);
+    d_4_0_Core->f.Uniform3dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform2dv(location, count, value);
+    d_4_0_Core->f.Uniform2dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform1dv(location, count, value);
+    d_4_0_Core->f.Uniform1dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_0_Core->Uniform4d(location, x, y, z, w);
+    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_0_Core->Uniform3d(location, x, y, z);
+    d_4_0_Core->f.Uniform3d(location, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform2d(GLint location, GLdouble x, GLdouble y)
 {
-    d_4_0_Core->Uniform2d(location, x, y);
+    d_4_0_Core->f.Uniform2d(location, x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUniform1d(GLint location, GLdouble x)
 {
-    d_4_0_Core->Uniform1d(location, x);
+    d_4_0_Core->f.Uniform1d(location, x);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
 {
-    d_4_0_Core->DrawElementsIndirect(mode, type, indirect);
+    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawArraysIndirect(GLenum mode, const void *indirect)
 {
-    d_4_0_Core->DrawArraysIndirect(mode, indirect);
+    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-    d_4_0_Core->BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
 {
-    d_4_0_Core->BlendFunci(buf, src, dst);
+    d_4_0_Core->f.BlendFunci(buf, src, dst);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
 {
-    d_4_0_Core->BlendEquationSeparatei(buf, modeRGB, modeAlpha);
+    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBlendEquationi(GLuint buf, GLenum mode)
 {
-    d_4_0_Core->BlendEquationi(buf, mode);
+    d_4_0_Core->f.BlendEquationi(buf, mode);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMinSampleShading(GLfloat value)
 {
-    d_4_0_Core->MinSampleShading(value);
+    d_4_0_Core->f.MinSampleShading(value);
 }
 
 
 // OpenGL 4.1 core functions
 inline void QOpenGLFunctions_4_5_Compatibility::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
 {
-    d_4_1_Core->GetDoublei_v(target, index, data);
+    d_4_1_Core->f.GetDoublei_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
 {
-    d_4_1_Core->GetFloati_v(target, index, data);
+    d_4_1_Core->f.GetFloati_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
 {
-    d_4_1_Core->DepthRangeIndexed(index, n, f);
+    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
 {
-    d_4_1_Core->DepthRangeArrayv(first, count, v);
+    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glScissorIndexedv(GLuint index, const GLint *v)
 {
-    d_4_1_Core->ScissorIndexedv(index, v);
+    d_4_1_Core->f.ScissorIndexedv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
 {
-    d_4_1_Core->ScissorIndexed(index, left, bottom, width, height);
+    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
 {
-    d_4_1_Core->ScissorArrayv(first, count, v);
+    d_4_1_Core->f.ScissorArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glViewportIndexedfv(GLuint index, const GLfloat *v)
 {
-    d_4_1_Core->ViewportIndexedfv(index, v);
+    d_4_1_Core->f.ViewportIndexedfv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
 {
-    d_4_1_Core->ViewportIndexedf(index, x, y, w, h);
+    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
 {
-    d_4_1_Core->ViewportArrayv(first, count, v);
+    d_4_1_Core->f.ViewportArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_4_1_Core->GetVertexAttribLdv(index, pname, params);
+    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
-    d_4_1_Core->VertexAttribLPointer(index, size, type, stride, pointer);
+    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribL4dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL4dv(index, v);
+    d_4_1_Core->f.VertexAttribL4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribL3dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL3dv(index, v);
+    d_4_1_Core->f.VertexAttribL3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribL2dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL2dv(index, v);
+    d_4_1_Core->f.VertexAttribL2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribL1dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL1dv(index, v);
+    d_4_1_Core->f.VertexAttribL1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_1_Core->VertexAttribL4d(index, x, y, z, w);
+    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_1_Core->VertexAttribL3d(index, x, y, z);
+    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_4_1_Core->VertexAttribL2d(index, x, y);
+    d_4_1_Core->f.VertexAttribL2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribL1d(GLuint index, GLdouble x)
 {
-    d_4_1_Core->VertexAttribL1d(index, x);
+    d_4_1_Core->f.VertexAttribL1d(index, x);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_4_1_Core->GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glValidateProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->ValidateProgramPipeline(pipeline);
+    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform4uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_4_1_Core->ProgramUniform4ui(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform4dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
 {
-    d_4_1_Core->ProgramUniform4d(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform4fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_4_1_Core->ProgramUniform4f(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform4iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_4_1_Core->ProgramUniform4i(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform3uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_4_1_Core->ProgramUniform3ui(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform3dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
 {
-    d_4_1_Core->ProgramUniform3d(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform3fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_4_1_Core->ProgramUniform3f(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform3iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_4_1_Core->ProgramUniform3i(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform2uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
 {
-    d_4_1_Core->ProgramUniform2ui(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform2dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
 {
-    d_4_1_Core->ProgramUniform2d(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform2fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
 {
-    d_4_1_Core->ProgramUniform2f(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform2iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
 {
-    d_4_1_Core->ProgramUniform2i(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform1uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
 {
-    d_4_1_Core->ProgramUniform1ui(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform1dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
 {
-    d_4_1_Core->ProgramUniform1d(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform1fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
 {
-    d_4_1_Core->ProgramUniform1f(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform1iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramUniform1i(GLuint program, GLint location, GLint v0)
 {
-    d_4_1_Core->ProgramUniform1i(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
 {
-    d_4_1_Core->GetProgramPipelineiv(pipeline, pname, params);
+    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsProgramPipeline(GLuint pipeline)
 {
-    return d_4_1_Core->IsProgramPipeline(pipeline);
+    return d_4_1_Core->f.IsProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
 {
-    d_4_1_Core->GenProgramPipelines(n, pipelines);
+    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
 {
-    d_4_1_Core->DeleteProgramPipelines(n, pipelines);
+    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->BindProgramPipeline(pipeline);
+    d_4_1_Core->f.BindProgramPipeline(pipeline);
 }
 
 inline GLuint QOpenGLFunctions_4_5_Compatibility::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
 {
-    return d_4_1_Core->CreateShaderProgramv(type, count, strings);
+    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glActiveShaderProgram(GLuint pipeline, GLuint program)
 {
-    d_4_1_Core->ActiveShaderProgram(pipeline, program);
+    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
 {
-    d_4_1_Core->UseProgramStages(pipeline, stages, program);
+    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramParameteri(GLuint program, GLenum pname, GLint value)
 {
-    d_4_1_Core->ProgramParameteri(program, pname, value);
+    d_4_1_Core->f.ProgramParameteri(program, pname, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
 {
-    d_4_1_Core->ProgramBinary(program, binaryFormat, binary, length);
+    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)
 {
-    d_4_1_Core->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
+    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearDepthf(GLfloat dd)
 {
-    d_4_1_Core->ClearDepthf(dd);
+    d_4_1_Core->f.ClearDepthf(dd);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDepthRangef(GLfloat n, GLfloat f)
 {
-    d_4_1_Core->DepthRangef(n, f);
+    d_4_1_Core->f.DepthRangef(n, f);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
 {
-    d_4_1_Core->GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length)
 {
-    d_4_1_Core->ShaderBinary(count, shaders, binaryformat, binary, length);
+    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glReleaseShaderCompiler()
 {
-    d_4_1_Core->ReleaseShaderCompiler();
+    d_4_1_Core->f.ReleaseShaderCompiler();
 }
 
 
 // OpenGL 4.2 core functions
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
 {
-    d_4_2_Core->DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
+    d_4_2_Core->f.DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
 {
-    d_4_2_Core->DrawTransformFeedbackInstanced(mode, id, instancecount);
+    d_4_2_Core->f.DrawTransformFeedbackInstanced(mode, id, instancecount);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
-    d_4_2_Core->TexStorage3D(target, levels, internalformat, width, height, depth);
+    d_4_2_Core->f.TexStorage3D(target, levels, internalformat, width, height, depth);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_4_2_Core->TexStorage2D(target, levels, internalformat, width, height);
+    d_4_2_Core->f.TexStorage2D(target, levels, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
 {
-    d_4_2_Core->TexStorage1D(target, levels, internalformat, width);
+    d_4_2_Core->f.TexStorage1D(target, levels, internalformat, width);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMemoryBarrier(GLbitfield barriers)
 {
-    d_4_2_Core->MemoryBarrier(barriers);
+    d_4_2_Core->f.MemoryBarrier(barriers);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
 {
-    d_4_2_Core->BindImageTexture(unit, texture, level, layered, layer, access, format);
+    d_4_2_Core->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
 {
-    d_4_2_Core->GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
+    d_4_2_Core->f.GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
 {
-    d_4_2_Core->GetInternalformativ(target, internalformat, pname, bufSize, params);
+    d_4_2_Core->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
 {
-    d_4_2_Core->DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
+    d_4_2_Core->f.DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
 {
-    d_4_2_Core->DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
+    d_4_2_Core->f.DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
 {
-    d_4_2_Core->DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
+    d_4_2_Core->f.DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
 }
 
 
 // OpenGL 4.3 core functions
 inline void QOpenGLFunctions_4_5_Compatibility::glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
 {
-    d_4_3_Core->GetObjectPtrLabel(ptr, bufSize, length, label);
+    d_4_3_Core->f.GetObjectPtrLabel(ptr, bufSize, length, label);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label)
 {
-    d_4_3_Core->ObjectPtrLabel(ptr, length, label);
+    d_4_3_Core->f.ObjectPtrLabel(ptr, length, label);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
 {
-    d_4_3_Core->GetObjectLabel(identifier, name, bufSize, length, label);
+    d_4_3_Core->f.GetObjectLabel(identifier, name, bufSize, length, label);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
 {
-    d_4_3_Core->ObjectLabel(identifier, name, length, label);
+    d_4_3_Core->f.ObjectLabel(identifier, name, length, label);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPopDebugGroup()
 {
-    d_4_3_Core->PopDebugGroup();
+    d_4_3_Core->f.PopDebugGroup();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message)
 {
-    d_4_3_Core->PushDebugGroup(source, id, length, message);
+    d_4_3_Core->f.PushDebugGroup(source, id, length, message);
 }
 
 inline GLuint QOpenGLFunctions_4_5_Compatibility::glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
 {
-    return d_4_3_Core->GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
+    return d_4_3_Core->f.GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
 {
-    d_4_3_Core->DebugMessageCallback(callback, userParam);
+    d_4_3_Core->f.DebugMessageCallback(callback, userParam);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
 {
-    d_4_3_Core->DebugMessageInsert(source, type, id, severity, length, buf);
+    d_4_3_Core->f.DebugMessageInsert(source, type, id, severity, length, buf);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)
 {
-    d_4_3_Core->DebugMessageControl(source, type, severity, count, ids, enabled);
+    d_4_3_Core->f.DebugMessageControl(source, type, severity, count, ids, enabled);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
 {
-    d_4_3_Core->VertexBindingDivisor(bindingindex, divisor);
+    d_4_3_Core->f.VertexBindingDivisor(bindingindex, divisor);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
 {
-    d_4_3_Core->VertexAttribBinding(attribindex, bindingindex);
+    d_4_3_Core->f.VertexAttribBinding(attribindex, bindingindex);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribLFormat(attribindex, size, type, relativeoffset);
+    d_4_3_Core->f.VertexAttribLFormat(attribindex, size, type, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribIFormat(attribindex, size, type, relativeoffset);
+    d_4_3_Core->f.VertexAttribIFormat(attribindex, size, type, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
+    d_4_3_Core->f.VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
 {
-    d_4_3_Core->BindVertexBuffer(bindingindex, buffer, offset, stride);
+    d_4_3_Core->f.BindVertexBuffer(bindingindex, buffer, offset, stride);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
 {
-    d_4_3_Core->TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
+    d_4_3_Core->f.TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_4_3_Core->TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_4_3_Core->f.TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_4_3_Core->TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_4_3_Core->f.TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_4_3_Core->TexBufferRange(target, internalformat, buffer, offset, size);
+    d_4_3_Core->f.TexBufferRange(target, internalformat, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
 {
-    d_4_3_Core->ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
+    d_4_3_Core->f.ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
 }
 
 inline GLint QOpenGLFunctions_4_5_Compatibility::glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceLocationIndex(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceLocationIndex(program, programInterface, name);
 }
 
 inline GLint QOpenGLFunctions_4_5_Compatibility::glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceLocation(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceLocation(program, programInterface, name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
 {
-    d_4_3_Core->GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
+    d_4_3_Core->f.GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
 {
-    d_4_3_Core->GetProgramResourceName(program, programInterface, index, bufSize, length, name);
+    d_4_3_Core->f.GetProgramResourceName(program, programInterface, index, bufSize, length, name);
 }
 
 inline GLuint QOpenGLFunctions_4_5_Compatibility::glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceIndex(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceIndex(program, programInterface, name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params)
 {
-    d_4_3_Core->GetProgramInterfaceiv(program, programInterface, pname, params);
+    d_4_3_Core->f.GetProgramInterfaceiv(program, programInterface, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
 {
-    d_4_3_Core->MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
+    d_4_3_Core->f.MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
 {
-    d_4_3_Core->MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
+    d_4_3_Core->f.MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_4_3_Core->InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
+    d_4_3_Core->f.InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
 {
-    d_4_3_Core->InvalidateFramebuffer(target, numAttachments, attachments);
+    d_4_3_Core->f.InvalidateFramebuffer(target, numAttachments, attachments);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glInvalidateBufferData(GLuint buffer)
 {
-    d_4_3_Core->InvalidateBufferData(buffer);
+    d_4_3_Core->f.InvalidateBufferData(buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
 {
-    d_4_3_Core->InvalidateBufferSubData(buffer, offset, length);
+    d_4_3_Core->f.InvalidateBufferSubData(buffer, offset, length);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glInvalidateTexImage(GLuint texture, GLint level)
 {
-    d_4_3_Core->InvalidateTexImage(texture, level);
+    d_4_3_Core->f.InvalidateTexImage(texture, level);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
 {
-    d_4_3_Core->InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
+    d_4_3_Core->f.InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)
 {
-    d_4_3_Core->GetInternalformati64v(target, internalformat, pname, bufSize, params);
+    d_4_3_Core->f.GetInternalformati64v(target, internalformat, pname, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_4_3_Core->GetFramebufferParameteriv(target, pname, params);
+    d_4_3_Core->f.GetFramebufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_4_3_Core->FramebufferParameteri(target, pname, param);
+    d_4_3_Core->f.FramebufferParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
 {
-    d_4_3_Core->CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
+    d_4_3_Core->f.CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDispatchComputeIndirect(GLintptr indirect)
 {
-    d_4_3_Core->DispatchComputeIndirect(indirect);
+    d_4_3_Core->f.DispatchComputeIndirect(indirect);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
 {
-    d_4_3_Core->DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
+    d_4_3_Core->f.DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
 {
-    d_4_3_Core->ClearBufferSubData(target, internalformat, offset, size, format, type, data);
+    d_4_3_Core->f.ClearBufferSubData(target, internalformat, offset, size, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)
 {
-    d_4_3_Core->ClearBufferData(target, internalformat, format, type, data);
+    d_4_3_Core->f.ClearBufferData(target, internalformat, format, type, data);
 }
 
 
 // OpenGL 4.4 core functions
 inline void QOpenGLFunctions_4_5_Compatibility::glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
 {
-    d_4_4_Core->BindVertexBuffers(first, count, buffers, offsets, strides);
+    d_4_4_Core->f.BindVertexBuffers(first, count, buffers, offsets, strides);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures)
 {
-    d_4_4_Core->BindImageTextures(first, count, textures);
+    d_4_4_Core->f.BindImageTextures(first, count, textures);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers)
 {
-    d_4_4_Core->BindSamplers(first, count, samplers);
+    d_4_4_Core->f.BindSamplers(first, count, samplers);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindTextures(GLuint first, GLsizei count, const GLuint *textures)
 {
-    d_4_4_Core->BindTextures(first, count, textures);
+    d_4_4_Core->f.BindTextures(first, count, textures);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes)
 {
-    d_4_4_Core->BindBuffersRange(target, first, count, buffers, offsets, sizes);
+    d_4_4_Core->f.BindBuffersRange(target, first, count, buffers, offsets, sizes);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers)
 {
-    d_4_4_Core->BindBuffersBase(target, first, count, buffers);
+    d_4_4_Core->f.BindBuffersBase(target, first, count, buffers);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data)
 {
-    d_4_4_Core->ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
+    d_4_4_Core->f.ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data)
 {
-    d_4_4_Core->ClearTexImage(texture, level, format, type, data);
+    d_4_4_Core->f.ClearTexImage(texture, level, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)
 {
-    d_4_4_Core->BufferStorage(target, size, data, flags);
+    d_4_4_Core->f.BufferStorage(target, size, data, flags);
 }
 
 
 // OpenGL 4.5 core functions
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureBarrier()
 {
-    d_4_5_Core->TextureBarrier();
+    d_4_5_Core->f.TextureBarrier();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)
 {
-    d_4_5_Core->ReadnPixels(x, y, width, height, format, type, bufSize, data);
+    d_4_5_Core->f.ReadnPixels(x, y, width, height, format, type, bufSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint *params)
 {
-    d_4_5_Core->GetnUniformuiv(program, location, bufSize, params);
+    d_4_5_Core->f.GetnUniformuiv(program, location, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params)
 {
-    d_4_5_Core->GetnUniformiv(program, location, bufSize, params);
+    d_4_5_Core->f.GetnUniformiv(program, location, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
 {
-    d_4_5_Core->GetnUniformfv(program, location, bufSize, params);
+    d_4_5_Core->f.GetnUniformfv(program, location, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnUniformdv(GLuint program, GLint location, GLsizei bufSize, GLdouble *params)
 {
-    d_4_5_Core->GetnUniformdv(program, location, bufSize, params);
+    d_4_5_Core->f.GetnUniformdv(program, location, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
 {
-    d_4_5_Core->GetnTexImage(target, level, format, type, bufSize, pixels);
+    d_4_5_Core->f.GetnTexImage(target, level, format, type, bufSize, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnCompressedTexImage(GLenum target, GLint lod, GLsizei bufSize, void *pixels)
 {
-    d_4_5_Core->GetnCompressedTexImage(target, lod, bufSize, pixels);
+    d_4_5_Core->f.GetnCompressedTexImage(target, lod, bufSize, pixels);
 }
 
 inline GLenum QOpenGLFunctions_4_5_Compatibility::glGetGraphicsResetStatus()
 {
-    return d_4_5_Core->GetGraphicsResetStatus();
+    return d_4_5_Core->f.GetGraphicsResetStatus();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetCompressedTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels)
 {
-    d_4_5_Core->GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
+    d_4_5_Core->f.GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
 {
-    d_4_5_Core->GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
+    d_4_5_Core->f.GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMemoryBarrierByRegion(GLbitfield barriers)
 {
-    d_4_5_Core->MemoryBarrierByRegion(barriers);
+    d_4_5_Core->f.MemoryBarrierByRegion(barriers);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCreateQueries(GLenum target, GLsizei n, GLuint *ids)
 {
-    d_4_5_Core->CreateQueries(target, n, ids);
+    d_4_5_Core->f.CreateQueries(target, n, ids);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCreateProgramPipelines(GLsizei n, GLuint *pipelines)
 {
-    d_4_5_Core->CreateProgramPipelines(n, pipelines);
+    d_4_5_Core->f.CreateProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCreateSamplers(GLsizei n, GLuint *samplers)
 {
-    d_4_5_Core->CreateSamplers(n, samplers);
+    d_4_5_Core->f.CreateSamplers(n, samplers);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexArrayIndexed64iv(GLuint vaobj, GLuint index, GLenum pname, GLint64 *param)
 {
-    d_4_5_Core->GetVertexArrayIndexed64iv(vaobj, index, pname, param);
+    d_4_5_Core->f.GetVertexArrayIndexed64iv(vaobj, index, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexArrayIndexediv(GLuint vaobj, GLuint index, GLenum pname, GLint *param)
 {
-    d_4_5_Core->GetVertexArrayIndexediv(vaobj, index, pname, param);
+    d_4_5_Core->f.GetVertexArrayIndexediv(vaobj, index, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetVertexArrayiv(GLuint vaobj, GLenum pname, GLint *param)
 {
-    d_4_5_Core->GetVertexArrayiv(vaobj, pname, param);
+    d_4_5_Core->f.GetVertexArrayiv(vaobj, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexArrayBindingDivisor(GLuint vaobj, GLuint bindingindex, GLuint divisor)
 {
-    d_4_5_Core->VertexArrayBindingDivisor(vaobj, bindingindex, divisor);
+    d_4_5_Core->f.VertexArrayBindingDivisor(vaobj, bindingindex, divisor);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexArrayAttribLFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
 {
-    d_4_5_Core->VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);
+    d_4_5_Core->f.VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexArrayAttribIFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
 {
-    d_4_5_Core->VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);
+    d_4_5_Core->f.VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexArrayAttribFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
 {
-    d_4_5_Core->VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
+    d_4_5_Core->f.VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexArrayAttribBinding(GLuint vaobj, GLuint attribindex, GLuint bindingindex)
 {
-    d_4_5_Core->VertexArrayAttribBinding(vaobj, attribindex, bindingindex);
+    d_4_5_Core->f.VertexArrayAttribBinding(vaobj, attribindex, bindingindex);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexArrayVertexBuffers(GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
 {
-    d_4_5_Core->VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);
+    d_4_5_Core->f.VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexArrayVertexBuffer(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
 {
-    d_4_5_Core->VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);
+    d_4_5_Core->f.VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexArrayElementBuffer(GLuint vaobj, GLuint buffer)
 {
-    d_4_5_Core->VertexArrayElementBuffer(vaobj, buffer);
+    d_4_5_Core->f.VertexArrayElementBuffer(vaobj, buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEnableVertexArrayAttrib(GLuint vaobj, GLuint index)
 {
-    d_4_5_Core->EnableVertexArrayAttrib(vaobj, index);
+    d_4_5_Core->f.EnableVertexArrayAttrib(vaobj, index);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDisableVertexArrayAttrib(GLuint vaobj, GLuint index)
 {
-    d_4_5_Core->DisableVertexArrayAttrib(vaobj, index);
+    d_4_5_Core->f.DisableVertexArrayAttrib(vaobj, index);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCreateVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_4_5_Core->CreateVertexArrays(n, arrays);
+    d_4_5_Core->f.CreateVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTextureParameteriv(GLuint texture, GLenum pname, GLint *params)
 {
-    d_4_5_Core->GetTextureParameteriv(texture, pname, params);
+    d_4_5_Core->f.GetTextureParameteriv(texture, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTextureParameterIuiv(GLuint texture, GLenum pname, GLuint *params)
 {
-    d_4_5_Core->GetTextureParameterIuiv(texture, pname, params);
+    d_4_5_Core->f.GetTextureParameterIuiv(texture, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTextureParameterIiv(GLuint texture, GLenum pname, GLint *params)
 {
-    d_4_5_Core->GetTextureParameterIiv(texture, pname, params);
+    d_4_5_Core->f.GetTextureParameterIiv(texture, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTextureParameterfv(GLuint texture, GLenum pname, GLfloat *params)
 {
-    d_4_5_Core->GetTextureParameterfv(texture, pname, params);
+    d_4_5_Core->f.GetTextureParameterfv(texture, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTextureLevelParameteriv(GLuint texture, GLint level, GLenum pname, GLint *params)
 {
-    d_4_5_Core->GetTextureLevelParameteriv(texture, level, pname, params);
+    d_4_5_Core->f.GetTextureLevelParameteriv(texture, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTextureLevelParameterfv(GLuint texture, GLint level, GLenum pname, GLfloat *params)
 {
-    d_4_5_Core->GetTextureLevelParameterfv(texture, level, pname, params);
+    d_4_5_Core->f.GetTextureLevelParameterfv(texture, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetCompressedTextureImage(GLuint texture, GLint level, GLsizei bufSize, void *pixels)
 {
-    d_4_5_Core->GetCompressedTextureImage(texture, level, bufSize, pixels);
+    d_4_5_Core->f.GetCompressedTextureImage(texture, level, bufSize, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTextureImage(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
 {
-    d_4_5_Core->GetTextureImage(texture, level, format, type, bufSize, pixels);
+    d_4_5_Core->f.GetTextureImage(texture, level, format, type, bufSize, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBindTextureUnit(GLuint unit, GLuint texture)
 {
-    d_4_5_Core->BindTextureUnit(unit, texture);
+    d_4_5_Core->f.BindTextureUnit(unit, texture);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGenerateTextureMipmap(GLuint texture)
 {
-    d_4_5_Core->GenerateTextureMipmap(texture);
+    d_4_5_Core->f.GenerateTextureMipmap(texture);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureParameteriv(GLuint texture, GLenum pname, const GLint *param)
 {
-    d_4_5_Core->TextureParameteriv(texture, pname, param);
+    d_4_5_Core->f.TextureParameteriv(texture, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureParameterIuiv(GLuint texture, GLenum pname, const GLuint *params)
 {
-    d_4_5_Core->TextureParameterIuiv(texture, pname, params);
+    d_4_5_Core->f.TextureParameterIuiv(texture, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureParameterIiv(GLuint texture, GLenum pname, const GLint *params)
 {
-    d_4_5_Core->TextureParameterIiv(texture, pname, params);
+    d_4_5_Core->f.TextureParameterIiv(texture, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureParameteri(GLuint texture, GLenum pname, GLint param)
 {
-    d_4_5_Core->TextureParameteri(texture, pname, param);
+    d_4_5_Core->f.TextureParameteri(texture, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureParameterfv(GLuint texture, GLenum pname, const GLfloat *param)
 {
-    d_4_5_Core->TextureParameterfv(texture, pname, param);
+    d_4_5_Core->f.TextureParameterfv(texture, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureParameterf(GLuint texture, GLenum pname, GLfloat param)
 {
-    d_4_5_Core->TextureParameterf(texture, pname, param);
+    d_4_5_Core->f.TextureParameterf(texture, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCopyTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_4_5_Core->CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_4_5_Core->f.CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCopyTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_4_5_Core->CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
+    d_4_5_Core->f.CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCopyTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_4_5_Core->CopyTextureSubImage1D(texture, level, xoffset, x, y, width);
+    d_4_5_Core->f.CopyTextureSubImage1D(texture, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_4_5_Core->CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_4_5_Core->f.CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_4_5_Core->CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_4_5_Core->f.CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCompressedTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_4_5_Core->CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
+    d_4_5_Core->f.CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
 {
-    d_4_5_Core->TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_4_5_Core->f.TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
 {
-    d_4_5_Core->TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_4_5_Core->f.TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
 {
-    d_4_5_Core->TextureSubImage1D(texture, level, xoffset, width, format, type, pixels);
+    d_4_5_Core->f.TextureSubImage1D(texture, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureStorage3DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_4_5_Core->TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_4_5_Core->f.TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureStorage2DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_4_5_Core->TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);
+    d_4_5_Core->f.TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureStorage3D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
-    d_4_5_Core->TextureStorage3D(texture, levels, internalformat, width, height, depth);
+    d_4_5_Core->f.TextureStorage3D(texture, levels, internalformat, width, height, depth);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureStorage2D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_4_5_Core->TextureStorage2D(texture, levels, internalformat, width, height);
+    d_4_5_Core->f.TextureStorage2D(texture, levels, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureStorage1D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width)
 {
-    d_4_5_Core->TextureStorage1D(texture, levels, internalformat, width);
+    d_4_5_Core->f.TextureStorage1D(texture, levels, internalformat, width);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureBufferRange(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizei size)
 {
-    d_4_5_Core->TextureBufferRange(texture, internalformat, buffer, offset, size);
+    d_4_5_Core->f.TextureBufferRange(texture, internalformat, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTextureBuffer(GLuint texture, GLenum internalformat, GLuint buffer)
 {
-    d_4_5_Core->TextureBuffer(texture, internalformat, buffer);
+    d_4_5_Core->f.TextureBuffer(texture, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCreateTextures(GLenum target, GLsizei n, GLuint *textures)
 {
-    d_4_5_Core->CreateTextures(target, n, textures);
+    d_4_5_Core->f.CreateTextures(target, n, textures);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetNamedRenderbufferParameteriv(GLuint renderbuffer, GLenum pname, GLint *params)
 {
-    d_4_5_Core->GetNamedRenderbufferParameteriv(renderbuffer, pname, params);
+    d_4_5_Core->f.GetNamedRenderbufferParameteriv(renderbuffer, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNamedRenderbufferStorageMultisample(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_4_5_Core->NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
+    d_4_5_Core->f.NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNamedRenderbufferStorage(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_4_5_Core->NamedRenderbufferStorage(renderbuffer, internalformat, width, height);
+    d_4_5_Core->f.NamedRenderbufferStorage(renderbuffer, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCreateRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_4_5_Core->CreateRenderbuffers(n, renderbuffers);
+    d_4_5_Core->f.CreateRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetNamedFramebufferAttachmentParameteriv(GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_4_5_Core->GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
+    d_4_5_Core->f.GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetNamedFramebufferParameteriv(GLuint framebuffer, GLenum pname, GLint *param)
 {
-    d_4_5_Core->GetNamedFramebufferParameteriv(framebuffer, pname, param);
+    d_4_5_Core->f.GetNamedFramebufferParameteriv(framebuffer, pname, param);
 }
 
 inline GLenum QOpenGLFunctions_4_5_Compatibility::glCheckNamedFramebufferStatus(GLuint framebuffer, GLenum target)
 {
-    return d_4_5_Core->CheckNamedFramebufferStatus(framebuffer, target);
+    return d_4_5_Core->f.CheckNamedFramebufferStatus(framebuffer, target);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBlitNamedFramebuffer(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_4_5_Core->BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_4_5_Core->f.BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearNamedFramebufferfi(GLuint framebuffer, GLenum buffer, GLfloat depth, GLint stencil)
 {
-    d_4_5_Core->ClearNamedFramebufferfi(framebuffer, buffer, depth, stencil);
+    d_4_5_Core->f.ClearNamedFramebufferfi(framebuffer, buffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearNamedFramebufferfv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_4_5_Core->ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
+    d_4_5_Core->f.ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearNamedFramebufferuiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_4_5_Core->ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
+    d_4_5_Core->f.ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearNamedFramebufferiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_4_5_Core->ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
+    d_4_5_Core->f.ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glInvalidateNamedFramebufferSubData(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_4_5_Core->InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);
+    d_4_5_Core->f.InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glInvalidateNamedFramebufferData(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments)
 {
-    d_4_5_Core->InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments);
+    d_4_5_Core->f.InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNamedFramebufferReadBuffer(GLuint framebuffer, GLenum src)
 {
-    d_4_5_Core->NamedFramebufferReadBuffer(framebuffer, src);
+    d_4_5_Core->f.NamedFramebufferReadBuffer(framebuffer, src);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNamedFramebufferDrawBuffers(GLuint framebuffer, GLsizei n, const GLenum *bufs)
 {
-    d_4_5_Core->NamedFramebufferDrawBuffers(framebuffer, n, bufs);
+    d_4_5_Core->f.NamedFramebufferDrawBuffers(framebuffer, n, bufs);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNamedFramebufferDrawBuffer(GLuint framebuffer, GLenum buf)
 {
-    d_4_5_Core->NamedFramebufferDrawBuffer(framebuffer, buf);
+    d_4_5_Core->f.NamedFramebufferDrawBuffer(framebuffer, buf);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNamedFramebufferTextureLayer(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_4_5_Core->NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
+    d_4_5_Core->f.NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNamedFramebufferTexture(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)
 {
-    d_4_5_Core->NamedFramebufferTexture(framebuffer, attachment, texture, level);
+    d_4_5_Core->f.NamedFramebufferTexture(framebuffer, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNamedFramebufferParameteri(GLuint framebuffer, GLenum pname, GLint param)
 {
-    d_4_5_Core->NamedFramebufferParameteri(framebuffer, pname, param);
+    d_4_5_Core->f.NamedFramebufferParameteri(framebuffer, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNamedFramebufferRenderbuffer(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_4_5_Core->NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);
+    d_4_5_Core->f.NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCreateFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_4_5_Core->CreateFramebuffers(n, framebuffers);
+    d_4_5_Core->f.CreateFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizei size, void *data)
 {
-    d_4_5_Core->GetNamedBufferSubData(buffer, offset, size, data);
+    d_4_5_Core->f.GetNamedBufferSubData(buffer, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetNamedBufferPointerv(GLuint buffer, GLenum pname, void * *params)
 {
-    d_4_5_Core->GetNamedBufferPointerv(buffer, pname, params);
+    d_4_5_Core->f.GetNamedBufferPointerv(buffer, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetNamedBufferParameteri64v(GLuint buffer, GLenum pname, GLint64 *params)
 {
-    d_4_5_Core->GetNamedBufferParameteri64v(buffer, pname, params);
+    d_4_5_Core->f.GetNamedBufferParameteri64v(buffer, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetNamedBufferParameteriv(GLuint buffer, GLenum pname, GLint *params)
 {
-    d_4_5_Core->GetNamedBufferParameteriv(buffer, pname, params);
+    d_4_5_Core->f.GetNamedBufferParameteriv(buffer, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFlushMappedNamedBufferRange(GLuint buffer, GLintptr offset, GLsizei length)
 {
-    d_4_5_Core->FlushMappedNamedBufferRange(buffer, offset, length);
+    d_4_5_Core->f.FlushMappedNamedBufferRange(buffer, offset, length);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glUnmapNamedBuffer(GLuint buffer)
 {
-    return d_4_5_Core->UnmapNamedBuffer(buffer);
+    return d_4_5_Core->f.UnmapNamedBuffer(buffer);
 }
 
 inline void * QOpenGLFunctions_4_5_Compatibility::glMapNamedBufferRange(GLuint buffer, GLintptr offset, GLsizei length, GLbitfield access)
 {
-    return d_4_5_Core->MapNamedBufferRange(buffer, offset, length, access);
+    return d_4_5_Core->f.MapNamedBufferRange(buffer, offset, length, access);
 }
 
 inline void * QOpenGLFunctions_4_5_Compatibility::glMapNamedBuffer(GLuint buffer, GLenum access)
 {
-    return d_4_5_Core->MapNamedBuffer(buffer, access);
+    return d_4_5_Core->f.MapNamedBuffer(buffer, access);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearNamedBufferSubData(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizei size, GLenum format, GLenum type, const void *data)
 {
-    d_4_5_Core->ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);
+    d_4_5_Core->f.ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearNamedBufferData(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data)
 {
-    d_4_5_Core->ClearNamedBufferData(buffer, internalformat, format, type, data);
+    d_4_5_Core->f.ClearNamedBufferData(buffer, internalformat, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCopyNamedBufferSubData(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizei size)
 {
-    d_4_5_Core->CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);
+    d_4_5_Core->f.CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizei size, const void *data)
 {
-    d_4_5_Core->NamedBufferSubData(buffer, offset, size, data);
+    d_4_5_Core->f.NamedBufferSubData(buffer, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNamedBufferData(GLuint buffer, GLsizei size, const void *data, GLenum usage)
 {
-    d_4_5_Core->NamedBufferData(buffer, size, data, usage);
+    d_4_5_Core->f.NamedBufferData(buffer, size, data, usage);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNamedBufferStorage(GLuint buffer, GLsizei size, const void *data, GLbitfield flags)
 {
-    d_4_5_Core->NamedBufferStorage(buffer, size, data, flags);
+    d_4_5_Core->f.NamedBufferStorage(buffer, size, data, flags);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCreateBuffers(GLsizei n, GLuint *buffers)
 {
-    d_4_5_Core->CreateBuffers(n, buffers);
+    d_4_5_Core->f.CreateBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, GLint64 *param)
 {
-    d_4_5_Core->GetTransformFeedbacki64_v(xfb, pname, index, param);
+    d_4_5_Core->f.GetTransformFeedbacki64_v(xfb, pname, index, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, GLint *param)
 {
-    d_4_5_Core->GetTransformFeedbacki_v(xfb, pname, index, param);
+    d_4_5_Core->f.GetTransformFeedbacki_v(xfb, pname, index, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTransformFeedbackiv(GLuint xfb, GLenum pname, GLint *param)
 {
-    d_4_5_Core->GetTransformFeedbackiv(xfb, pname, param);
+    d_4_5_Core->f.GetTransformFeedbackiv(xfb, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTransformFeedbackBufferRange(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizei size)
 {
-    d_4_5_Core->TransformFeedbackBufferRange(xfb, index, buffer, offset, size);
+    d_4_5_Core->f.TransformFeedbackBufferRange(xfb, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer)
 {
-    d_4_5_Core->TransformFeedbackBufferBase(xfb, index, buffer);
+    d_4_5_Core->f.TransformFeedbackBufferBase(xfb, index, buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCreateTransformFeedbacks(GLsizei n, GLuint *ids)
 {
-    d_4_5_Core->CreateTransformFeedbacks(n, ids);
+    d_4_5_Core->f.CreateTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClipControl(GLenum origin, GLenum depth)
 {
-    d_4_5_Core->ClipControl(origin, depth);
+    d_4_5_Core->f.ClipControl(origin, depth);
 }
 
 
 // OpenGL 1.0 deprecated functions
 inline void QOpenGLFunctions_4_5_Compatibility::glTranslatef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Translatef(x, y, z);
+    d_1_0_Deprecated->f.Translatef(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTranslated(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Translated(x, y, z);
+    d_1_0_Deprecated->f.Translated(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glScalef(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Scalef(x, y, z);
+    d_1_0_Deprecated->f.Scalef(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glScaled(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Scaled(x, y, z);
+    d_1_0_Deprecated->f.Scaled(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Rotatef(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotatef(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Rotated(angle, x, y, z);
+    d_1_0_Deprecated->f.Rotated(angle, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPushMatrix()
 {
-    d_1_0_Deprecated->PushMatrix();
+    d_1_0_Deprecated->f.PushMatrix();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPopMatrix()
 {
-    d_1_0_Deprecated->PopMatrix();
+    d_1_0_Deprecated->f.PopMatrix();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Ortho(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Ortho(left, right, bottom, top, zNear, zFar);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->MultMatrixd(m);
+    d_1_0_Deprecated->f.MultMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->MultMatrixf(m);
+    d_1_0_Deprecated->f.MultMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMatrixMode(GLenum mode)
 {
-    d_1_0_Deprecated->MatrixMode(mode);
+    d_1_0_Deprecated->f.MatrixMode(mode);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLoadMatrixd(const GLdouble *m)
 {
-    d_1_0_Deprecated->LoadMatrixd(m);
+    d_1_0_Deprecated->f.LoadMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLoadMatrixf(const GLfloat *m)
 {
-    d_1_0_Deprecated->LoadMatrixf(m);
+    d_1_0_Deprecated->f.LoadMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLoadIdentity()
 {
-    d_1_0_Deprecated->LoadIdentity();
+    d_1_0_Deprecated->f.LoadIdentity();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
 {
-    d_1_0_Deprecated->Frustum(left, right, bottom, top, zNear, zFar);
+    d_1_0_Deprecated->f.Frustum(left, right, bottom, top, zNear, zFar);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glIsList(GLuint list)
 {
-    return d_1_0_Deprecated->IsList(list);
+    return d_1_0_Deprecated->f.IsList(list);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
 {
-    d_1_0_Deprecated->GetTexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.GetTexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetTexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetTexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.GetTexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetPolygonStipple(GLubyte *mask)
 {
-    d_1_0_Deprecated->GetPolygonStipple(mask);
+    d_1_0_Deprecated->f.GetPolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetPixelMapusv(GLenum map, GLushort *values)
 {
-    d_1_0_Deprecated->GetPixelMapusv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapusv(map, values);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetPixelMapuiv(GLenum map, GLuint *values)
 {
-    d_1_0_Deprecated->GetPixelMapuiv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapuiv(map, values);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetPixelMapfv(GLenum map, GLfloat *values)
 {
-    d_1_0_Deprecated->GetPixelMapfv(map, values);
+    d_1_0_Deprecated->f.GetPixelMapfv(map, values);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetMaterialiv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetMaterialfv(face, pname, params);
+    d_1_0_Deprecated->f.GetMaterialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetMapiv(GLenum target, GLenum query, GLint *v)
 {
-    d_1_0_Deprecated->GetMapiv(target, query, v);
+    d_1_0_Deprecated->f.GetMapiv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetMapfv(GLenum target, GLenum query, GLfloat *v)
 {
-    d_1_0_Deprecated->GetMapfv(target, query, v);
+    d_1_0_Deprecated->f.GetMapfv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetMapdv(GLenum target, GLenum query, GLdouble *v)
 {
-    d_1_0_Deprecated->GetMapdv(target, query, v);
+    d_1_0_Deprecated->f.GetMapdv(target, query, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetLightiv(GLenum light, GLenum pname, GLint *params)
 {
-    d_1_0_Deprecated->GetLightiv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
 {
-    d_1_0_Deprecated->GetLightfv(light, pname, params);
+    d_1_0_Deprecated->f.GetLightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetClipPlane(GLenum plane, GLdouble *equation)
 {
-    d_1_0_Deprecated->GetClipPlane(plane, equation);
+    d_1_0_Deprecated->f.GetClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_0_Deprecated->DrawPixels(width, height, format, type, pixels);
+    d_1_0_Deprecated->f.DrawPixels(width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
 {
-    d_1_0_Deprecated->CopyPixels(x, y, width, height, type);
+    d_1_0_Deprecated->f.CopyPixels(x, y, width, height, type);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
 {
-    d_1_0_Deprecated->PixelMapusv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapusv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
 {
-    d_1_0_Deprecated->PixelMapuiv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapuiv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
 {
-    d_1_0_Deprecated->PixelMapfv(map, mapsize, values);
+    d_1_0_Deprecated->f.PixelMapfv(map, mapsize, values);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPixelTransferi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->PixelTransferi(pname, param);
+    d_1_0_Deprecated->f.PixelTransferi(pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPixelTransferf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->PixelTransferf(pname, param);
+    d_1_0_Deprecated->f.PixelTransferf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPixelZoom(GLfloat xfactor, GLfloat yfactor)
 {
-    d_1_0_Deprecated->PixelZoom(xfactor, yfactor);
+    d_1_0_Deprecated->f.PixelZoom(xfactor, yfactor);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glAlphaFunc(GLenum func, GLfloat ref)
 {
-    d_1_0_Deprecated->AlphaFunc(func, ref);
+    d_1_0_Deprecated->f.AlphaFunc(func, ref);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEvalPoint2(GLint i, GLint j)
 {
-    d_1_0_Deprecated->EvalPoint2(i, j);
+    d_1_0_Deprecated->f.EvalPoint2(i, j);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
 {
-    d_1_0_Deprecated->EvalMesh2(mode, i1, i2, j1, j2);
+    d_1_0_Deprecated->f.EvalMesh2(mode, i1, i2, j1, j2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEvalPoint1(GLint i)
 {
-    d_1_0_Deprecated->EvalPoint1(i);
+    d_1_0_Deprecated->f.EvalPoint1(i);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEvalMesh1(GLenum mode, GLint i1, GLint i2)
 {
-    d_1_0_Deprecated->EvalMesh1(mode, i1, i2);
+    d_1_0_Deprecated->f.EvalMesh1(mode, i1, i2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEvalCoord2fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord2fv(u);
+    d_1_0_Deprecated->f.EvalCoord2fv(u);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEvalCoord2f(GLfloat u, GLfloat v)
 {
-    d_1_0_Deprecated->EvalCoord2f(u, v);
+    d_1_0_Deprecated->f.EvalCoord2f(u, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEvalCoord2dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord2dv(u);
+    d_1_0_Deprecated->f.EvalCoord2dv(u);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEvalCoord2d(GLdouble u, GLdouble v)
 {
-    d_1_0_Deprecated->EvalCoord2d(u, v);
+    d_1_0_Deprecated->f.EvalCoord2d(u, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEvalCoord1fv(const GLfloat *u)
 {
-    d_1_0_Deprecated->EvalCoord1fv(u);
+    d_1_0_Deprecated->f.EvalCoord1fv(u);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEvalCoord1f(GLfloat u)
 {
-    d_1_0_Deprecated->EvalCoord1f(u);
+    d_1_0_Deprecated->f.EvalCoord1f(u);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEvalCoord1dv(const GLdouble *u)
 {
-    d_1_0_Deprecated->EvalCoord1dv(u);
+    d_1_0_Deprecated->f.EvalCoord1dv(u);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEvalCoord1d(GLdouble u)
 {
-    d_1_0_Deprecated->EvalCoord1d(u);
+    d_1_0_Deprecated->f.EvalCoord1d(u);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
 {
-    d_1_0_Deprecated->MapGrid2f(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2f(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
 {
-    d_1_0_Deprecated->MapGrid2d(un, u1, u2, vn, v1, v2);
+    d_1_0_Deprecated->f.MapGrid2d(un, u1, u2, vn, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
 {
-    d_1_0_Deprecated->MapGrid1f(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1f(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
 {
-    d_1_0_Deprecated->MapGrid1d(un, u1, u2);
+    d_1_0_Deprecated->f.MapGrid1d(un, u1, u2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2f(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
+    d_1_0_Deprecated->f.Map2d(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
 {
-    d_1_0_Deprecated->Map1f(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1f(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
 {
-    d_1_0_Deprecated->Map1d(target, u1, u2, stride, order, points);
+    d_1_0_Deprecated->f.Map1d(target, u1, u2, stride, order, points);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPushAttrib(GLbitfield mask)
 {
-    d_1_0_Deprecated->PushAttrib(mask);
+    d_1_0_Deprecated->f.PushAttrib(mask);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPopAttrib()
 {
-    d_1_0_Deprecated->PopAttrib();
+    d_1_0_Deprecated->f.PopAttrib();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glAccum(GLenum op, GLfloat value)
 {
-    d_1_0_Deprecated->Accum(op, value);
+    d_1_0_Deprecated->f.Accum(op, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glIndexMask(GLuint mask)
 {
-    d_1_0_Deprecated->IndexMask(mask);
+    d_1_0_Deprecated->f.IndexMask(mask);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearIndex(GLfloat c)
 {
-    d_1_0_Deprecated->ClearIndex(c);
+    d_1_0_Deprecated->f.ClearIndex(c);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->ClearAccum(red, green, blue, alpha);
+    d_1_0_Deprecated->f.ClearAccum(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPushName(GLuint name)
 {
-    d_1_0_Deprecated->PushName(name);
+    d_1_0_Deprecated->f.PushName(name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPopName()
 {
-    d_1_0_Deprecated->PopName();
+    d_1_0_Deprecated->f.PopName();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPassThrough(GLfloat token)
 {
-    d_1_0_Deprecated->PassThrough(token);
+    d_1_0_Deprecated->f.PassThrough(token);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLoadName(GLuint name)
 {
-    d_1_0_Deprecated->LoadName(name);
+    d_1_0_Deprecated->f.LoadName(name);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glInitNames()
 {
-    d_1_0_Deprecated->InitNames();
+    d_1_0_Deprecated->f.InitNames();
 }
 
 inline GLint QOpenGLFunctions_4_5_Compatibility::glRenderMode(GLenum mode)
 {
-    return d_1_0_Deprecated->RenderMode(mode);
+    return d_1_0_Deprecated->f.RenderMode(mode);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSelectBuffer(GLsizei size, GLuint *buffer)
 {
-    d_1_0_Deprecated->SelectBuffer(size, buffer);
+    d_1_0_Deprecated->f.SelectBuffer(size, buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
 {
-    d_1_0_Deprecated->FeedbackBuffer(size, type, buffer);
+    d_1_0_Deprecated->f.FeedbackBuffer(size, type, buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexGeniv(GLenum coord, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexGeniv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGeniv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexGeni(GLenum coord, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexGeni(coord, pname, param);
+    d_1_0_Deprecated->f.TexGeni(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexGenfv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGenfv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexGenf(GLenum coord, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexGenf(coord, pname, param);
+    d_1_0_Deprecated->f.TexGenf(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
 {
-    d_1_0_Deprecated->TexGendv(coord, pname, params);
+    d_1_0_Deprecated->f.TexGendv(coord, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexGend(GLenum coord, GLenum pname, GLdouble param)
 {
-    d_1_0_Deprecated->TexGend(coord, pname, param);
+    d_1_0_Deprecated->f.TexGend(coord, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexEnviv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->TexEnviv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnviv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexEnvi(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->TexEnvi(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvi(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->TexEnvfv(target, pname, params);
+    d_1_0_Deprecated->f.TexEnvfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexEnvf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->TexEnvf(target, pname, param);
+    d_1_0_Deprecated->f.TexEnvf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glShadeModel(GLenum mode)
 {
-    d_1_0_Deprecated->ShadeModel(mode);
+    d_1_0_Deprecated->f.ShadeModel(mode);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPolygonStipple(const GLubyte *mask)
 {
-    d_1_0_Deprecated->PolygonStipple(mask);
+    d_1_0_Deprecated->f.PolygonStipple(mask);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMaterialiv(GLenum face, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Materialiv(face, pname, params);
+    d_1_0_Deprecated->f.Materialiv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMateriali(GLenum face, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Materiali(face, pname, param);
+    d_1_0_Deprecated->f.Materiali(face, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Materialfv(face, pname, params);
+    d_1_0_Deprecated->f.Materialfv(face, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMaterialf(GLenum face, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Materialf(face, pname, param);
+    d_1_0_Deprecated->f.Materialf(face, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLineStipple(GLint factor, GLushort pattern)
 {
-    d_1_0_Deprecated->LineStipple(factor, pattern);
+    d_1_0_Deprecated->f.LineStipple(factor, pattern);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLightModeliv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->LightModeliv(pname, params);
+    d_1_0_Deprecated->f.LightModeliv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLightModeli(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->LightModeli(pname, param);
+    d_1_0_Deprecated->f.LightModeli(pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLightModelfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->LightModelfv(pname, params);
+    d_1_0_Deprecated->f.LightModelfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLightModelf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->LightModelf(pname, param);
+    d_1_0_Deprecated->f.LightModelf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLightiv(GLenum light, GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Lightiv(light, pname, params);
+    d_1_0_Deprecated->f.Lightiv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLighti(GLenum light, GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Lighti(light, pname, param);
+    d_1_0_Deprecated->f.Lighti(light, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLightfv(GLenum light, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Lightfv(light, pname, params);
+    d_1_0_Deprecated->f.Lightfv(light, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLightf(GLenum light, GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Lightf(light, pname, param);
+    d_1_0_Deprecated->f.Lightf(light, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFogiv(GLenum pname, const GLint *params)
 {
-    d_1_0_Deprecated->Fogiv(pname, params);
+    d_1_0_Deprecated->f.Fogiv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFogi(GLenum pname, GLint param)
 {
-    d_1_0_Deprecated->Fogi(pname, param);
+    d_1_0_Deprecated->f.Fogi(pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFogfv(GLenum pname, const GLfloat *params)
 {
-    d_1_0_Deprecated->Fogfv(pname, params);
+    d_1_0_Deprecated->f.Fogfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFogf(GLenum pname, GLfloat param)
 {
-    d_1_0_Deprecated->Fogf(pname, param);
+    d_1_0_Deprecated->f.Fogf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColorMaterial(GLenum face, GLenum mode)
 {
-    d_1_0_Deprecated->ColorMaterial(face, mode);
+    d_1_0_Deprecated->f.ColorMaterial(face, mode);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClipPlane(GLenum plane, const GLdouble *equation)
 {
-    d_1_0_Deprecated->ClipPlane(plane, equation);
+    d_1_0_Deprecated->f.ClipPlane(plane, equation);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex4sv(v);
+    d_1_0_Deprecated->f.Vertex4sv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->Vertex4s(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex4iv(v);
+    d_1_0_Deprecated->f.Vertex4iv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->Vertex4i(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex4fv(v);
+    d_1_0_Deprecated->f.Vertex4fv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->Vertex4f(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex4dv(v);
+    d_1_0_Deprecated->f.Vertex4dv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->Vertex4d(x, y, z, w);
+    d_1_0_Deprecated->f.Vertex4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex3sv(v);
+    d_1_0_Deprecated->f.Vertex3sv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->Vertex3s(x, y, z);
+    d_1_0_Deprecated->f.Vertex3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex3iv(v);
+    d_1_0_Deprecated->f.Vertex3iv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->Vertex3i(x, y, z);
+    d_1_0_Deprecated->f.Vertex3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex3fv(v);
+    d_1_0_Deprecated->f.Vertex3fv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->Vertex3f(x, y, z);
+    d_1_0_Deprecated->f.Vertex3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex3dv(v);
+    d_1_0_Deprecated->f.Vertex3dv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->Vertex3d(x, y, z);
+    d_1_0_Deprecated->f.Vertex3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Vertex2sv(v);
+    d_1_0_Deprecated->f.Vertex2sv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->Vertex2s(x, y);
+    d_1_0_Deprecated->f.Vertex2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex2iv(const GLint *v)
 {
-    d_1_0_Deprecated->Vertex2iv(v);
+    d_1_0_Deprecated->f.Vertex2iv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->Vertex2i(x, y);
+    d_1_0_Deprecated->f.Vertex2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Vertex2fv(v);
+    d_1_0_Deprecated->f.Vertex2fv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->Vertex2f(x, y);
+    d_1_0_Deprecated->f.Vertex2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Vertex2dv(v);
+    d_1_0_Deprecated->f.Vertex2dv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertex2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->Vertex2d(x, y);
+    d_1_0_Deprecated->f.Vertex2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord4sv(v);
+    d_1_0_Deprecated->f.TexCoord4sv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord4s(GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_0_Deprecated->TexCoord4s(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4s(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord4iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord4iv(v);
+    d_1_0_Deprecated->f.TexCoord4iv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord4i(GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_0_Deprecated->TexCoord4i(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4i(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord4fv(v);
+    d_1_0_Deprecated->f.TexCoord4fv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_0_Deprecated->TexCoord4f(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4f(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord4dv(v);
+    d_1_0_Deprecated->f.TexCoord4dv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_0_Deprecated->TexCoord4d(s, t, r, q);
+    d_1_0_Deprecated->f.TexCoord4d(s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord3sv(v);
+    d_1_0_Deprecated->f.TexCoord3sv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord3s(GLshort s, GLshort t, GLshort r)
 {
-    d_1_0_Deprecated->TexCoord3s(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3s(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord3iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord3iv(v);
+    d_1_0_Deprecated->f.TexCoord3iv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord3i(GLint s, GLint t, GLint r)
 {
-    d_1_0_Deprecated->TexCoord3i(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3i(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord3fv(v);
+    d_1_0_Deprecated->f.TexCoord3fv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_0_Deprecated->TexCoord3f(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3f(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord3dv(v);
+    d_1_0_Deprecated->f.TexCoord3dv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_0_Deprecated->TexCoord3d(s, t, r);
+    d_1_0_Deprecated->f.TexCoord3d(s, t, r);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord2sv(v);
+    d_1_0_Deprecated->f.TexCoord2sv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord2s(GLshort s, GLshort t)
 {
-    d_1_0_Deprecated->TexCoord2s(s, t);
+    d_1_0_Deprecated->f.TexCoord2s(s, t);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord2iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord2iv(v);
+    d_1_0_Deprecated->f.TexCoord2iv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord2i(GLint s, GLint t)
 {
-    d_1_0_Deprecated->TexCoord2i(s, t);
+    d_1_0_Deprecated->f.TexCoord2i(s, t);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord2fv(v);
+    d_1_0_Deprecated->f.TexCoord2fv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord2f(GLfloat s, GLfloat t)
 {
-    d_1_0_Deprecated->TexCoord2f(s, t);
+    d_1_0_Deprecated->f.TexCoord2f(s, t);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord2dv(v);
+    d_1_0_Deprecated->f.TexCoord2dv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord2d(GLdouble s, GLdouble t)
 {
-    d_1_0_Deprecated->TexCoord2d(s, t);
+    d_1_0_Deprecated->f.TexCoord2d(s, t);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord1sv(const GLshort *v)
 {
-    d_1_0_Deprecated->TexCoord1sv(v);
+    d_1_0_Deprecated->f.TexCoord1sv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord1s(GLshort s)
 {
-    d_1_0_Deprecated->TexCoord1s(s);
+    d_1_0_Deprecated->f.TexCoord1s(s);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord1iv(const GLint *v)
 {
-    d_1_0_Deprecated->TexCoord1iv(v);
+    d_1_0_Deprecated->f.TexCoord1iv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord1i(GLint s)
 {
-    d_1_0_Deprecated->TexCoord1i(s);
+    d_1_0_Deprecated->f.TexCoord1i(s);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord1fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->TexCoord1fv(v);
+    d_1_0_Deprecated->f.TexCoord1fv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord1f(GLfloat s)
 {
-    d_1_0_Deprecated->TexCoord1f(s);
+    d_1_0_Deprecated->f.TexCoord1f(s);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord1dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->TexCoord1dv(v);
+    d_1_0_Deprecated->f.TexCoord1dv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoord1d(GLdouble s)
 {
-    d_1_0_Deprecated->TexCoord1d(s);
+    d_1_0_Deprecated->f.TexCoord1d(s);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRectsv(const GLshort *v1, const GLshort *v2)
 {
-    d_1_0_Deprecated->Rectsv(v1, v2);
+    d_1_0_Deprecated->f.Rectsv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
 {
-    d_1_0_Deprecated->Rects(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rects(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRectiv(const GLint *v1, const GLint *v2)
 {
-    d_1_0_Deprecated->Rectiv(v1, v2);
+    d_1_0_Deprecated->f.Rectiv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
 {
-    d_1_0_Deprecated->Recti(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Recti(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRectfv(const GLfloat *v1, const GLfloat *v2)
 {
-    d_1_0_Deprecated->Rectfv(v1, v2);
+    d_1_0_Deprecated->f.Rectfv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
 {
-    d_1_0_Deprecated->Rectf(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectf(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRectdv(const GLdouble *v1, const GLdouble *v2)
 {
-    d_1_0_Deprecated->Rectdv(v1, v2);
+    d_1_0_Deprecated->f.Rectdv(v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
 {
-    d_1_0_Deprecated->Rectd(x1, y1, x2, y2);
+    d_1_0_Deprecated->f.Rectd(x1, y1, x2, y2);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos4sv(v);
+    d_1_0_Deprecated->f.RasterPos4sv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_1_0_Deprecated->RasterPos4s(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4s(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos4iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos4iv(v);
+    d_1_0_Deprecated->f.RasterPos4iv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
 {
-    d_1_0_Deprecated->RasterPos4i(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4i(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos4fv(v);
+    d_1_0_Deprecated->f.RasterPos4fv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_1_0_Deprecated->RasterPos4f(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4f(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos4dv(v);
+    d_1_0_Deprecated->f.RasterPos4dv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_1_0_Deprecated->RasterPos4d(x, y, z, w);
+    d_1_0_Deprecated->f.RasterPos4d(x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos3sv(v);
+    d_1_0_Deprecated->f.RasterPos3sv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_0_Deprecated->RasterPos3s(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos3iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos3iv(v);
+    d_1_0_Deprecated->f.RasterPos3iv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_0_Deprecated->RasterPos3i(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos3fv(v);
+    d_1_0_Deprecated->f.RasterPos3fv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_0_Deprecated->RasterPos3f(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos3dv(v);
+    d_1_0_Deprecated->f.RasterPos3dv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_0_Deprecated->RasterPos3d(x, y, z);
+    d_1_0_Deprecated->f.RasterPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos2sv(const GLshort *v)
 {
-    d_1_0_Deprecated->RasterPos2sv(v);
+    d_1_0_Deprecated->f.RasterPos2sv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos2s(GLshort x, GLshort y)
 {
-    d_1_0_Deprecated->RasterPos2s(x, y);
+    d_1_0_Deprecated->f.RasterPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos2iv(const GLint *v)
 {
-    d_1_0_Deprecated->RasterPos2iv(v);
+    d_1_0_Deprecated->f.RasterPos2iv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos2i(GLint x, GLint y)
 {
-    d_1_0_Deprecated->RasterPos2i(x, y);
+    d_1_0_Deprecated->f.RasterPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos2fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->RasterPos2fv(v);
+    d_1_0_Deprecated->f.RasterPos2fv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos2f(GLfloat x, GLfloat y)
 {
-    d_1_0_Deprecated->RasterPos2f(x, y);
+    d_1_0_Deprecated->f.RasterPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos2dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->RasterPos2dv(v);
+    d_1_0_Deprecated->f.RasterPos2dv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glRasterPos2d(GLdouble x, GLdouble y)
 {
-    d_1_0_Deprecated->RasterPos2d(x, y);
+    d_1_0_Deprecated->f.RasterPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNormal3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Normal3sv(v);
+    d_1_0_Deprecated->f.Normal3sv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNormal3s(GLshort nx, GLshort ny, GLshort nz)
 {
-    d_1_0_Deprecated->Normal3s(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3s(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNormal3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Normal3iv(v);
+    d_1_0_Deprecated->f.Normal3iv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNormal3i(GLint nx, GLint ny, GLint nz)
 {
-    d_1_0_Deprecated->Normal3i(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3i(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNormal3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Normal3fv(v);
+    d_1_0_Deprecated->f.Normal3fv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
 {
-    d_1_0_Deprecated->Normal3f(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3f(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNormal3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Normal3dv(v);
+    d_1_0_Deprecated->f.Normal3dv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
 {
-    d_1_0_Deprecated->Normal3d(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3d(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNormal3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Normal3bv(v);
+    d_1_0_Deprecated->f.Normal3bv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
 {
-    d_1_0_Deprecated->Normal3b(nx, ny, nz);
+    d_1_0_Deprecated->f.Normal3b(nx, ny, nz);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glIndexsv(const GLshort *c)
 {
-    d_1_0_Deprecated->Indexsv(c);
+    d_1_0_Deprecated->f.Indexsv(c);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glIndexs(GLshort c)
 {
-    d_1_0_Deprecated->Indexs(c);
+    d_1_0_Deprecated->f.Indexs(c);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glIndexiv(const GLint *c)
 {
-    d_1_0_Deprecated->Indexiv(c);
+    d_1_0_Deprecated->f.Indexiv(c);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glIndexi(GLint c)
 {
-    d_1_0_Deprecated->Indexi(c);
+    d_1_0_Deprecated->f.Indexi(c);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glIndexfv(const GLfloat *c)
 {
-    d_1_0_Deprecated->Indexfv(c);
+    d_1_0_Deprecated->f.Indexfv(c);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glIndexf(GLfloat c)
 {
-    d_1_0_Deprecated->Indexf(c);
+    d_1_0_Deprecated->f.Indexf(c);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glIndexdv(const GLdouble *c)
 {
-    d_1_0_Deprecated->Indexdv(c);
+    d_1_0_Deprecated->f.Indexdv(c);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glIndexd(GLdouble c)
 {
-    d_1_0_Deprecated->Indexd(c);
+    d_1_0_Deprecated->f.Indexd(c);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEnd()
 {
-    d_1_0_Deprecated->End();
+    d_1_0_Deprecated->f.End();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEdgeFlagv(const GLboolean *flag)
 {
-    d_1_0_Deprecated->EdgeFlagv(flag);
+    d_1_0_Deprecated->f.EdgeFlagv(flag);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEdgeFlag(GLboolean flag)
 {
-    d_1_0_Deprecated->EdgeFlag(flag);
+    d_1_0_Deprecated->f.EdgeFlag(flag);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor4usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color4usv(v);
+    d_1_0_Deprecated->f.Color4usv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
 {
-    d_1_0_Deprecated->Color4us(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4us(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor4uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color4uiv(v);
+    d_1_0_Deprecated->f.Color4uiv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
 {
-    d_1_0_Deprecated->Color4ui(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ui(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor4ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color4ubv(v);
+    d_1_0_Deprecated->f.Color4ubv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
 {
-    d_1_0_Deprecated->Color4ub(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4ub(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor4sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color4sv(v);
+    d_1_0_Deprecated->f.Color4sv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
 {
-    d_1_0_Deprecated->Color4s(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4s(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor4iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color4iv(v);
+    d_1_0_Deprecated->f.Color4iv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
 {
-    d_1_0_Deprecated->Color4i(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4i(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor4fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color4fv(v);
+    d_1_0_Deprecated->f.Color4fv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Deprecated->Color4f(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4f(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor4dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color4dv(v);
+    d_1_0_Deprecated->f.Color4dv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
 {
-    d_1_0_Deprecated->Color4d(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4d(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor4bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color4bv(v);
+    d_1_0_Deprecated->f.Color4bv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
 {
-    d_1_0_Deprecated->Color4b(red, green, blue, alpha);
+    d_1_0_Deprecated->f.Color4b(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor3usv(const GLushort *v)
 {
-    d_1_0_Deprecated->Color3usv(v);
+    d_1_0_Deprecated->f.Color3usv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_0_Deprecated->Color3us(red, green, blue);
+    d_1_0_Deprecated->f.Color3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor3uiv(const GLuint *v)
 {
-    d_1_0_Deprecated->Color3uiv(v);
+    d_1_0_Deprecated->f.Color3uiv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_0_Deprecated->Color3ui(red, green, blue);
+    d_1_0_Deprecated->f.Color3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor3ubv(const GLubyte *v)
 {
-    d_1_0_Deprecated->Color3ubv(v);
+    d_1_0_Deprecated->f.Color3ubv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_0_Deprecated->Color3ub(red, green, blue);
+    d_1_0_Deprecated->f.Color3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor3sv(const GLshort *v)
 {
-    d_1_0_Deprecated->Color3sv(v);
+    d_1_0_Deprecated->f.Color3sv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_0_Deprecated->Color3s(red, green, blue);
+    d_1_0_Deprecated->f.Color3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor3iv(const GLint *v)
 {
-    d_1_0_Deprecated->Color3iv(v);
+    d_1_0_Deprecated->f.Color3iv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_0_Deprecated->Color3i(red, green, blue);
+    d_1_0_Deprecated->f.Color3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor3fv(const GLfloat *v)
 {
-    d_1_0_Deprecated->Color3fv(v);
+    d_1_0_Deprecated->f.Color3fv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_0_Deprecated->Color3f(red, green, blue);
+    d_1_0_Deprecated->f.Color3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor3dv(const GLdouble *v)
 {
-    d_1_0_Deprecated->Color3dv(v);
+    d_1_0_Deprecated->f.Color3dv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_0_Deprecated->Color3d(red, green, blue);
+    d_1_0_Deprecated->f.Color3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor3bv(const GLbyte *v)
 {
-    d_1_0_Deprecated->Color3bv(v);
+    d_1_0_Deprecated->f.Color3bv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_0_Deprecated->Color3b(red, green, blue);
+    d_1_0_Deprecated->f.Color3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
 {
-    d_1_0_Deprecated->Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
+    d_1_0_Deprecated->f.Bitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glBegin(GLenum mode)
 {
-    d_1_0_Deprecated->Begin(mode);
+    d_1_0_Deprecated->f.Begin(mode);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glListBase(GLuint base)
 {
-    d_1_0_Deprecated->ListBase(base);
+    d_1_0_Deprecated->f.ListBase(base);
 }
 
 inline GLuint QOpenGLFunctions_4_5_Compatibility::glGenLists(GLsizei range)
 {
-    return d_1_0_Deprecated->GenLists(range);
+    return d_1_0_Deprecated->f.GenLists(range);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDeleteLists(GLuint list, GLsizei range)
 {
-    d_1_0_Deprecated->DeleteLists(list, range);
+    d_1_0_Deprecated->f.DeleteLists(list, range);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCallLists(GLsizei n, GLenum type, const void *lists)
 {
-    d_1_0_Deprecated->CallLists(n, type, lists);
+    d_1_0_Deprecated->f.CallLists(n, type, lists);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCallList(GLuint list)
 {
-    d_1_0_Deprecated->CallList(list);
+    d_1_0_Deprecated->f.CallList(list);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEndList()
 {
-    d_1_0_Deprecated->EndList();
+    d_1_0_Deprecated->f.EndList();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNewList(GLuint list, GLenum mode)
 {
-    d_1_0_Deprecated->NewList(list, mode);
+    d_1_0_Deprecated->f.NewList(list, mode);
 }
 
 
 // OpenGL 1.1 deprecated functions
 inline void QOpenGLFunctions_4_5_Compatibility::glPushClientAttrib(GLbitfield mask)
 {
-    d_1_1_Deprecated->PushClientAttrib(mask);
+    d_1_1_Deprecated->f.PushClientAttrib(mask);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPopClientAttrib()
 {
-    d_1_1_Deprecated->PopClientAttrib();
+    d_1_1_Deprecated->f.PopClientAttrib();
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glIndexubv(const GLubyte *c)
 {
-    d_1_1_Deprecated->Indexubv(c);
+    d_1_1_Deprecated->f.Indexubv(c);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glIndexub(GLubyte c)
 {
-    d_1_1_Deprecated->Indexub(c);
+    d_1_1_Deprecated->f.Indexub(c);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLfloat *priorities)
 {
-    d_1_1_Deprecated->PrioritizeTextures(n, textures, priorities);
+    d_1_1_Deprecated->f.PrioritizeTextures(n, textures, priorities);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Compatibility::glAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
 {
-    return d_1_1_Deprecated->AreTexturesResident(n, textures, residences);
+    return d_1_1_Deprecated->f.AreTexturesResident(n, textures, residences);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
-    d_1_1_Deprecated->VertexPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.VertexPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
-    d_1_1_Deprecated->TexCoordPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.TexCoordPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNormalPointer(GLenum type, GLsizei stride, const void *pointer)
 {
-    d_1_1_Deprecated->NormalPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.NormalPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glInterleavedArrays(GLenum format, GLsizei stride, const void *pointer)
 {
-    d_1_1_Deprecated->InterleavedArrays(format, stride, pointer);
+    d_1_1_Deprecated->f.InterleavedArrays(format, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetPointerv(GLenum pname, void * *params)
 {
-    d_1_1_Deprecated->GetPointerv(pname, params);
+    d_1_1_Deprecated->f.GetPointerv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glIndexPointer(GLenum type, GLsizei stride, const void *pointer)
 {
-    d_1_1_Deprecated->IndexPointer(type, stride, pointer);
+    d_1_1_Deprecated->f.IndexPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEnableClientState(GLenum array)
 {
-    d_1_1_Deprecated->EnableClientState(array);
+    d_1_1_Deprecated->f.EnableClientState(array);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glEdgeFlagPointer(GLsizei stride, const void *pointer)
 {
-    d_1_1_Deprecated->EdgeFlagPointer(stride, pointer);
+    d_1_1_Deprecated->f.EdgeFlagPointer(stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glDisableClientState(GLenum array)
 {
-    d_1_1_Deprecated->DisableClientState(array);
+    d_1_1_Deprecated->f.DisableClientState(array);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
-    d_1_1_Deprecated->ColorPointer(size, type, stride, pointer);
+    d_1_1_Deprecated->f.ColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glArrayElement(GLint i)
 {
-    d_1_1_Deprecated->ArrayElement(i);
+    d_1_1_Deprecated->f.ArrayElement(i);
 }
 
 
 // OpenGL 1.2 deprecated functions
 inline void QOpenGLFunctions_4_5_Compatibility::glColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table)
 {
-    d_1_2_Deprecated->ColorTable(target, internalformat, width, format, type, table);
+    d_1_2_Deprecated->f.ColorTable(target, internalformat, width, format, type, table);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorTable(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyColorTable(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetColorTable(GLenum target, GLenum format, GLenum type, void *table)
 {
-    d_1_2_Deprecated->GetColorTable(target, format, type, table);
+    d_1_2_Deprecated->f.GetColorTable(target, format, type, table);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetColorTableParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetColorTableParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetColorTableParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data)
 {
-    d_1_2_Deprecated->ColorSubTable(target, start, count, format, type, data);
+    d_1_2_Deprecated->f.ColorSubTable(target, start, count, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyColorSubTable(target, start, x, y, width);
+    d_1_2_Deprecated->f.CopyColorSubTable(target, start, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter1D(target, internalformat, width, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter1D(target, internalformat, width, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image)
 {
-    d_1_2_Deprecated->ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
+    d_1_2_Deprecated->f.ConvolutionFilter2D(target, internalformat, width, height, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
 {
-    d_1_2_Deprecated->ConvolutionParameterf(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterf(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_2_Deprecated->ConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glConvolutionParameteri(GLenum target, GLenum pname, GLint params)
 {
-    d_1_2_Deprecated->ConvolutionParameteri(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteri(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_2_Deprecated->ConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.ConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter1D(target, internalformat, x, y, width);
+    d_1_2_Deprecated->f.CopyConvolutionFilter1D(target, internalformat, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Deprecated->CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
+    d_1_2_Deprecated->f.CopyConvolutionFilter2D(target, internalformat, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetConvolutionFilter(GLenum target, GLenum format, GLenum type, void *image)
 {
-    d_1_2_Deprecated->GetConvolutionFilter(target, format, type, image);
+    d_1_2_Deprecated->f.GetConvolutionFilter(target, format, type, image);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetConvolutionParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetConvolutionParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetSeparableFilter(GLenum target, GLenum format, GLenum type, void *row, void *column, void *span)
 {
-    d_1_2_Deprecated->GetSeparableFilter(target, format, type, row, column, span);
+    d_1_2_Deprecated->f.GetSeparableFilter(target, format, type, row, column, span);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column)
 {
-    d_1_2_Deprecated->SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
+    d_1_2_Deprecated->f.SeparableFilter2D(target, internalformat, width, height, format, type, row, column);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, void *values)
 {
-    d_1_2_Deprecated->GetHistogram(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetHistogram(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetHistogramParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetHistogramParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetHistogramParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, void *values)
 {
-    d_1_2_Deprecated->GetMinmax(target, reset, format, type, values);
+    d_1_2_Deprecated->f.GetMinmax(target, reset, format, type, values);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameterfv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_2_Deprecated->GetMinmaxParameteriv(target, pname, params);
+    d_1_2_Deprecated->f.GetMinmaxParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Histogram(target, width, internalformat, sink);
+    d_1_2_Deprecated->f.Histogram(target, width, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMinmax(GLenum target, GLenum internalformat, GLboolean sink)
 {
-    d_1_2_Deprecated->Minmax(target, internalformat, sink);
+    d_1_2_Deprecated->f.Minmax(target, internalformat, sink);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glResetHistogram(GLenum target)
 {
-    d_1_2_Deprecated->ResetHistogram(target);
+    d_1_2_Deprecated->f.ResetHistogram(target);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glResetMinmax(GLenum target)
 {
-    d_1_2_Deprecated->ResetMinmax(target);
+    d_1_2_Deprecated->f.ResetMinmax(target);
 }
 
 
 // OpenGL 1.3 deprecated functions
 inline void QOpenGLFunctions_4_5_Compatibility::glMultTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixd(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->MultTransposeMatrixf(m);
+    d_1_3_Deprecated->f.MultTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLoadTransposeMatrixd(const GLdouble *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixd(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixd(m);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glLoadTransposeMatrixf(const GLfloat *m)
 {
-    d_1_3_Deprecated->LoadTransposeMatrixf(m);
+    d_1_3_Deprecated->f.LoadTransposeMatrixf(m);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord4sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord4s(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)
 {
-    d_1_3_Deprecated->MultiTexCoord4s(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4s(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord4iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
 {
-    d_1_3_Deprecated->MultiTexCoord4i(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4i(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord4fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
 {
-    d_1_3_Deprecated->MultiTexCoord4f(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4f(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord4dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord4dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord4dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
 {
-    d_1_3_Deprecated->MultiTexCoord4d(target, s, t, r, q);
+    d_1_3_Deprecated->f.MultiTexCoord4d(target, s, t, r, q);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord3sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord3s(GLenum target, GLshort s, GLshort t, GLshort r)
 {
-    d_1_3_Deprecated->MultiTexCoord3s(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3s(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord3iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
 {
-    d_1_3_Deprecated->MultiTexCoord3i(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3i(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord3fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
 {
-    d_1_3_Deprecated->MultiTexCoord3f(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3f(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord3dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord3dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord3dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
 {
-    d_1_3_Deprecated->MultiTexCoord3d(target, s, t, r);
+    d_1_3_Deprecated->f.MultiTexCoord3d(target, s, t, r);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord2sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord2s(GLenum target, GLshort s, GLshort t)
 {
-    d_1_3_Deprecated->MultiTexCoord2s(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2s(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord2iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord2i(GLenum target, GLint s, GLint t)
 {
-    d_1_3_Deprecated->MultiTexCoord2i(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2i(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord2fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
 {
-    d_1_3_Deprecated->MultiTexCoord2f(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2f(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord2dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord2dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord2dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
 {
-    d_1_3_Deprecated->MultiTexCoord2d(target, s, t);
+    d_1_3_Deprecated->f.MultiTexCoord2d(target, s, t);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord1sv(GLenum target, const GLshort *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1sv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1sv(target, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord1s(GLenum target, GLshort s)
 {
-    d_1_3_Deprecated->MultiTexCoord1s(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1s(target, s);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord1iv(GLenum target, const GLint *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1iv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1iv(target, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord1i(GLenum target, GLint s)
 {
-    d_1_3_Deprecated->MultiTexCoord1i(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1i(target, s);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord1fv(GLenum target, const GLfloat *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1fv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1fv(target, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord1f(GLenum target, GLfloat s)
 {
-    d_1_3_Deprecated->MultiTexCoord1f(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1f(target, s);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord1dv(GLenum target, const GLdouble *v)
 {
-    d_1_3_Deprecated->MultiTexCoord1dv(target, v);
+    d_1_3_Deprecated->f.MultiTexCoord1dv(target, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoord1d(GLenum target, GLdouble s)
 {
-    d_1_3_Deprecated->MultiTexCoord1d(target, s);
+    d_1_3_Deprecated->f.MultiTexCoord1d(target, s);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glClientActiveTexture(GLenum texture)
 {
-    d_1_3_Deprecated->ClientActiveTexture(texture);
+    d_1_3_Deprecated->f.ClientActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 deprecated functions
 inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos3sv(v);
+    d_1_4_Deprecated->f.WindowPos3sv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos3s(GLshort x, GLshort y, GLshort z)
 {
-    d_1_4_Deprecated->WindowPos3s(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3s(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos3iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos3iv(v);
+    d_1_4_Deprecated->f.WindowPos3iv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos3i(GLint x, GLint y, GLint z)
 {
-    d_1_4_Deprecated->WindowPos3i(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3i(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos3fv(v);
+    d_1_4_Deprecated->f.WindowPos3fv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
 {
-    d_1_4_Deprecated->WindowPos3f(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3f(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos3dv(v);
+    d_1_4_Deprecated->f.WindowPos3dv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
 {
-    d_1_4_Deprecated->WindowPos3d(x, y, z);
+    d_1_4_Deprecated->f.WindowPos3d(x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos2sv(const GLshort *v)
 {
-    d_1_4_Deprecated->WindowPos2sv(v);
+    d_1_4_Deprecated->f.WindowPos2sv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos2s(GLshort x, GLshort y)
 {
-    d_1_4_Deprecated->WindowPos2s(x, y);
+    d_1_4_Deprecated->f.WindowPos2s(x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos2iv(const GLint *v)
 {
-    d_1_4_Deprecated->WindowPos2iv(v);
+    d_1_4_Deprecated->f.WindowPos2iv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos2i(GLint x, GLint y)
 {
-    d_1_4_Deprecated->WindowPos2i(x, y);
+    d_1_4_Deprecated->f.WindowPos2i(x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos2fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->WindowPos2fv(v);
+    d_1_4_Deprecated->f.WindowPos2fv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos2f(GLfloat x, GLfloat y)
 {
-    d_1_4_Deprecated->WindowPos2f(x, y);
+    d_1_4_Deprecated->f.WindowPos2f(x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos2dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->WindowPos2dv(v);
+    d_1_4_Deprecated->f.WindowPos2dv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glWindowPos2d(GLdouble x, GLdouble y)
 {
-    d_1_4_Deprecated->WindowPos2d(x, y);
+    d_1_4_Deprecated->f.WindowPos2d(x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
-    d_1_4_Deprecated->SecondaryColorPointer(size, type, stride, pointer);
+    d_1_4_Deprecated->f.SecondaryColorPointer(size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3usv(const GLushort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3usv(v);
+    d_1_4_Deprecated->f.SecondaryColor3usv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3us(GLushort red, GLushort green, GLushort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3us(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3us(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3uiv(const GLuint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3uiv(v);
+    d_1_4_Deprecated->f.SecondaryColor3uiv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ui(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ui(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3ubv(const GLubyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3ubv(v);
+    d_1_4_Deprecated->f.SecondaryColor3ubv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3ub(GLubyte red, GLubyte green, GLubyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3ub(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3ub(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3sv(const GLshort *v)
 {
-    d_1_4_Deprecated->SecondaryColor3sv(v);
+    d_1_4_Deprecated->f.SecondaryColor3sv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3s(GLshort red, GLshort green, GLshort blue)
 {
-    d_1_4_Deprecated->SecondaryColor3s(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3s(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3iv(const GLint *v)
 {
-    d_1_4_Deprecated->SecondaryColor3iv(v);
+    d_1_4_Deprecated->f.SecondaryColor3iv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3i(GLint red, GLint green, GLint blue)
 {
-    d_1_4_Deprecated->SecondaryColor3i(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3i(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3fv(const GLfloat *v)
 {
-    d_1_4_Deprecated->SecondaryColor3fv(v);
+    d_1_4_Deprecated->f.SecondaryColor3fv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
 {
-    d_1_4_Deprecated->SecondaryColor3f(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3f(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3dv(const GLdouble *v)
 {
-    d_1_4_Deprecated->SecondaryColor3dv(v);
+    d_1_4_Deprecated->f.SecondaryColor3dv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
 {
-    d_1_4_Deprecated->SecondaryColor3d(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3d(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3bv(const GLbyte *v)
 {
-    d_1_4_Deprecated->SecondaryColor3bv(v);
+    d_1_4_Deprecated->f.SecondaryColor3bv(v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColor3b(GLbyte red, GLbyte green, GLbyte blue)
 {
-    d_1_4_Deprecated->SecondaryColor3b(red, green, blue);
+    d_1_4_Deprecated->f.SecondaryColor3b(red, green, blue);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFogCoordPointer(GLenum type, GLsizei stride, const void *pointer)
 {
-    d_1_4_Deprecated->FogCoordPointer(type, stride, pointer);
+    d_1_4_Deprecated->f.FogCoordPointer(type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFogCoorddv(const GLdouble *coord)
 {
-    d_1_4_Deprecated->FogCoorddv(coord);
+    d_1_4_Deprecated->f.FogCoorddv(coord);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFogCoordd(GLdouble coord)
 {
-    d_1_4_Deprecated->FogCoordd(coord);
+    d_1_4_Deprecated->f.FogCoordd(coord);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFogCoordfv(const GLfloat *coord)
 {
-    d_1_4_Deprecated->FogCoordfv(coord);
+    d_1_4_Deprecated->f.FogCoordfv(coord);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glFogCoordf(GLfloat coord)
 {
-    d_1_4_Deprecated->FogCoordf(coord);
+    d_1_4_Deprecated->f.FogCoordf(coord);
 }
 
 
@@ -6454,152 +6455,152 @@ inline void QOpenGLFunctions_4_5_Compatibility::glFogCoordf(GLfloat coord)
 // OpenGL 3.3 deprecated functions
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColorP3uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->SecondaryColorP3uiv(type, color);
+    d_3_3_Deprecated->f.SecondaryColorP3uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glSecondaryColorP3ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->SecondaryColorP3ui(type, color);
+    d_3_3_Deprecated->f.SecondaryColorP3ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColorP4uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->ColorP4uiv(type, color);
+    d_3_3_Deprecated->f.ColorP4uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColorP4ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->ColorP4ui(type, color);
+    d_3_3_Deprecated->f.ColorP4ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColorP3uiv(GLenum type, const GLuint *color)
 {
-    d_3_3_Deprecated->ColorP3uiv(type, color);
+    d_3_3_Deprecated->f.ColorP3uiv(type, color);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glColorP3ui(GLenum type, GLuint color)
 {
-    d_3_3_Deprecated->ColorP3ui(type, color);
+    d_3_3_Deprecated->f.ColorP3ui(type, color);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNormalP3uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->NormalP3uiv(type, coords);
+    d_3_3_Deprecated->f.NormalP3uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glNormalP3ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->NormalP3ui(type, coords);
+    d_3_3_Deprecated->f.NormalP3ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP4uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP4uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP4ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP4ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP3uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP3uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP3ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP3ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP2uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP2uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP2ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP2ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP1uiv(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP1uiv(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->MultiTexCoordP1ui(texture, type, coords);
+    d_3_3_Deprecated->f.MultiTexCoordP1ui(texture, type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordP4uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP4uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP4uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordP4ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP4ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP4ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordP3uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP3uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP3uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordP3ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP3ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP3ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordP2uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP2uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP2uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordP2ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP2ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP2ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordP1uiv(GLenum type, const GLuint *coords)
 {
-    d_3_3_Deprecated->TexCoordP1uiv(type, coords);
+    d_3_3_Deprecated->f.TexCoordP1uiv(type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glTexCoordP1ui(GLenum type, GLuint coords)
 {
-    d_3_3_Deprecated->TexCoordP1ui(type, coords);
+    d_3_3_Deprecated->f.TexCoordP1ui(type, coords);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexP4uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP4uiv(type, value);
+    d_3_3_Deprecated->f.VertexP4uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexP4ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP4ui(type, value);
+    d_3_3_Deprecated->f.VertexP4ui(type, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexP3uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP3uiv(type, value);
+    d_3_3_Deprecated->f.VertexP3uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexP3ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP3ui(type, value);
+    d_3_3_Deprecated->f.VertexP3ui(type, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexP2uiv(GLenum type, const GLuint *value)
 {
-    d_3_3_Deprecated->VertexP2uiv(type, value);
+    d_3_3_Deprecated->f.VertexP2uiv(type, value);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glVertexP2ui(GLenum type, GLuint value)
 {
-    d_3_3_Deprecated->VertexP2ui(type, value);
+    d_3_3_Deprecated->f.VertexP2ui(type, value);
 }
 
 
@@ -6616,62 +6617,62 @@ inline void QOpenGLFunctions_4_5_Compatibility::glVertexP2ui(GLenum type, GLuint
 // OpenGL 4.5 deprecated functions
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnMinmax(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values)
 {
-    d_4_5_Deprecated->GetnMinmax(target, reset, format, type, bufSize, values);
+    d_4_5_Deprecated->f.GetnMinmax(target, reset, format, type, bufSize, values);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnHistogram(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, void *values)
 {
-    d_4_5_Deprecated->GetnHistogram(target, reset, format, type, bufSize, values);
+    d_4_5_Deprecated->f.GetnHistogram(target, reset, format, type, bufSize, values);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnSeparableFilter(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span)
 {
-    d_4_5_Deprecated->GetnSeparableFilter(target, format, type, rowBufSize, row, columnBufSize, column, span);
+    d_4_5_Deprecated->f.GetnSeparableFilter(target, format, type, rowBufSize, row, columnBufSize, column, span);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnConvolutionFilter(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image)
 {
-    d_4_5_Deprecated->GetnConvolutionFilter(target, format, type, bufSize, image);
+    d_4_5_Deprecated->f.GetnConvolutionFilter(target, format, type, bufSize, image);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnColorTable(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table)
 {
-    d_4_5_Deprecated->GetnColorTable(target, format, type, bufSize, table);
+    d_4_5_Deprecated->f.GetnColorTable(target, format, type, bufSize, table);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnPolygonStipple(GLsizei bufSize, GLubyte *pattern)
 {
-    d_4_5_Deprecated->GetnPolygonStipple(bufSize, pattern);
+    d_4_5_Deprecated->f.GetnPolygonStipple(bufSize, pattern);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnPixelMapusv(GLenum map, GLsizei bufSize, GLushort *values)
 {
-    d_4_5_Deprecated->GetnPixelMapusv(map, bufSize, values);
+    d_4_5_Deprecated->f.GetnPixelMapusv(map, bufSize, values);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnPixelMapuiv(GLenum map, GLsizei bufSize, GLuint *values)
 {
-    d_4_5_Deprecated->GetnPixelMapuiv(map, bufSize, values);
+    d_4_5_Deprecated->f.GetnPixelMapuiv(map, bufSize, values);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnPixelMapfv(GLenum map, GLsizei bufSize, GLfloat *values)
 {
-    d_4_5_Deprecated->GetnPixelMapfv(map, bufSize, values);
+    d_4_5_Deprecated->f.GetnPixelMapfv(map, bufSize, values);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnMapiv(GLenum target, GLenum query, GLsizei bufSize, GLint *v)
 {
-    d_4_5_Deprecated->GetnMapiv(target, query, bufSize, v);
+    d_4_5_Deprecated->f.GetnMapiv(target, query, bufSize, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnMapfv(GLenum target, GLenum query, GLsizei bufSize, GLfloat *v)
 {
-    d_4_5_Deprecated->GetnMapfv(target, query, bufSize, v);
+    d_4_5_Deprecated->f.GetnMapfv(target, query, bufSize, v);
 }
 
 inline void QOpenGLFunctions_4_5_Compatibility::glGetnMapdv(GLenum target, GLenum query, GLsizei bufSize, GLdouble *v)
 {
-    d_4_5_Deprecated->GetnMapdv(target, query, bufSize, v);
+    d_4_5_Deprecated->f.GetnMapdv(target, query, bufSize, v);
 }
 
 
diff --git a/src/gui/opengl/qopenglfunctions_4_5_core.cpp b/src/gui/opengl/qopenglfunctions_4_5_core.cpp
index be08a76a697..2fdb9ef855f 100644
--- a/src/gui/opengl/qopenglfunctions_4_5_core.cpp
+++ b/src/gui/opengl/qopenglfunctions_4_5_core.cpp
@@ -90,78 +90,60 @@ QOpenGLFunctions_4_5_Core::QOpenGLFunctions_4_5_Core()
 
 QOpenGLFunctions_4_5_Core::~QOpenGLFunctions_4_5_Core()
 {
-    if (d_1_0_Core && !d_1_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_0_Core->context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        delete d_1_0_Core;
-    }
-    if (d_1_1_Core && !d_1_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_1_Core->context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        delete d_1_1_Core;
-    }
-    if (d_1_2_Core && !d_1_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_2_Core->context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        delete d_1_2_Core;
-    }
-    if (d_1_3_Core && !d_1_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_3_Core->context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        delete d_1_3_Core;
-    }
-    if (d_1_4_Core && !d_1_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_4_Core->context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        delete d_1_4_Core;
-    }
-    if (d_1_5_Core && !d_1_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_1_5_Core->context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        delete d_1_5_Core;
-    }
-    if (d_2_0_Core && !d_2_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_0_Core->context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        delete d_2_0_Core;
-    }
-    if (d_2_1_Core && !d_2_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_2_1_Core->context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        delete d_2_1_Core;
-    }
-    if (d_3_0_Core && !d_3_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_0_Core->context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        delete d_3_0_Core;
-    }
-    if (d_3_1_Core && !d_3_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_1_Core->context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        delete d_3_1_Core;
-    }
-    if (d_3_2_Core && !d_3_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_2_Core->context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        delete d_3_2_Core;
-    }
-    if (d_3_3_Core && !d_3_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_3_3_Core->context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        delete d_3_3_Core;
-    }
-    if (d_4_0_Core && !d_4_0_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_0_Core->context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        delete d_4_0_Core;
-    }
-    if (d_4_1_Core && !d_4_1_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_1_Core->context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        delete d_4_1_Core;
-    }
-    if (d_4_2_Core && !d_4_2_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_2_Core->context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        delete d_4_2_Core;
-    }
-    if (d_4_3_Core && !d_4_3_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_3_Core->context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        delete d_4_3_Core;
-    }
-    if (d_4_4_Core && !d_4_4_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_4_Core->context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
-        delete d_4_4_Core;
-    }
-    if (d_4_5_Core && !d_4_5_Core->refs.deref()) {
-        QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(d_4_5_Core->context, QOpenGLFunctions_4_5_CoreBackend::versionStatus());
-        delete d_4_5_Core;
-    }
+    if (d_1_0_Core)
+        d_1_0_Core->refs.deref();
+    Q_ASSERT(d_1_0_Core->refs.load());
+    if (d_1_1_Core)
+        d_1_1_Core->refs.deref();
+    Q_ASSERT(d_1_1_Core->refs.load());
+    if (d_1_2_Core)
+        d_1_2_Core->refs.deref();
+    Q_ASSERT(d_1_2_Core->refs.load());
+    if (d_1_3_Core)
+        d_1_3_Core->refs.deref();
+    Q_ASSERT(d_1_3_Core->refs.load());
+    if (d_1_4_Core)
+        d_1_4_Core->refs.deref();
+    Q_ASSERT(d_1_4_Core->refs.load());
+    if (d_1_5_Core)
+        d_1_5_Core->refs.deref();
+    Q_ASSERT(d_1_5_Core->refs.load());
+    if (d_2_0_Core)
+        d_2_0_Core->refs.deref();
+    Q_ASSERT(d_2_0_Core->refs.load());
+    if (d_2_1_Core)
+        d_2_1_Core->refs.deref();
+    Q_ASSERT(d_2_1_Core->refs.load());
+    if (d_3_0_Core)
+        d_3_0_Core->refs.deref();
+    Q_ASSERT(d_3_0_Core->refs.load());
+    if (d_3_1_Core)
+        d_3_1_Core->refs.deref();
+    Q_ASSERT(d_3_1_Core->refs.load());
+    if (d_3_2_Core)
+        d_3_2_Core->refs.deref();
+    Q_ASSERT(d_3_2_Core->refs.load());
+    if (d_3_3_Core)
+        d_3_3_Core->refs.deref();
+    Q_ASSERT(d_3_3_Core->refs.load());
+    if (d_4_0_Core)
+        d_4_0_Core->refs.deref();
+    Q_ASSERT(d_4_0_Core->refs.load());
+    if (d_4_1_Core)
+        d_4_1_Core->refs.deref();
+    Q_ASSERT(d_4_1_Core->refs.load());
+    if (d_4_2_Core)
+        d_4_2_Core->refs.deref();
+    Q_ASSERT(d_4_2_Core->refs.load());
+    if (d_4_3_Core)
+        d_4_3_Core->refs.deref();
+    Q_ASSERT(d_4_3_Core->refs.load());
+    if (d_4_4_Core)
+        d_4_4_Core->refs.deref();
+    Q_ASSERT(d_4_4_Core->refs.load());
+    if (d_4_5_Core)
+        d_4_5_Core->refs.deref();
+    Q_ASSERT(d_4_5_Core->refs.load());
 }
 
 bool QOpenGLFunctions_4_5_Core::initializeOpenGLFunctions()
@@ -180,146 +162,74 @@ bool QOpenGLFunctions_4_5_Core::initializeOpenGLFunctions()
         // Function pointers in the backends are resolved at creation time
         QOpenGLVersionFunctionsBackend* d = 0;
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_0_CoreBackend::versionStatus(), d);
-        }
         d_1_0_Core = static_cast<QOpenGLFunctions_1_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_1_CoreBackend::versionStatus(), d);
-        }
         d_1_1_Core = static_cast<QOpenGLFunctions_1_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_2_CoreBackend::versionStatus(), d);
-        }
         d_1_2_Core = static_cast<QOpenGLFunctions_1_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_3_CoreBackend::versionStatus(), d);
-        }
         d_1_3_Core = static_cast<QOpenGLFunctions_1_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_4_CoreBackend::versionStatus(), d);
-        }
         d_1_4_Core = static_cast<QOpenGLFunctions_1_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_1_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_1_5_CoreBackend::versionStatus(), d);
-        }
         d_1_5_Core = static_cast<QOpenGLFunctions_1_5_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_0_CoreBackend::versionStatus(), d);
-        }
         d_2_0_Core = static_cast<QOpenGLFunctions_2_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_2_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_2_1_CoreBackend::versionStatus(), d);
-        }
         d_2_1_Core = static_cast<QOpenGLFunctions_2_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_0_CoreBackend::versionStatus(), d);
-        }
         d_3_0_Core = static_cast<QOpenGLFunctions_3_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_1_CoreBackend::versionStatus(), d);
-        }
         d_3_1_Core = static_cast<QOpenGLFunctions_3_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_2_CoreBackend::versionStatus(), d);
-        }
         d_3_2_Core = static_cast<QOpenGLFunctions_3_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_3_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_3_3_CoreBackend::versionStatus(), d);
-        }
         d_3_3_Core = static_cast<QOpenGLFunctions_3_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_0_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_0_CoreBackend::versionStatus(), d);
-        }
         d_4_0_Core = static_cast<QOpenGLFunctions_4_0_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_1_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_1_CoreBackend::versionStatus(), d);
-        }
         d_4_1_Core = static_cast<QOpenGLFunctions_4_1_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_2_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_2_CoreBackend::versionStatus(), d);
-        }
         d_4_2_Core = static_cast<QOpenGLFunctions_4_2_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_3_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_3_CoreBackend::versionStatus(), d);
-        }
         d_4_3_Core = static_cast<QOpenGLFunctions_4_3_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_4_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_4_CoreBackend::versionStatus(), d);
-        }
         d_4_4_Core = static_cast<QOpenGLFunctions_4_4_CoreBackend*>(d);
         d->refs.ref();
 
         d = QAbstractOpenGLFunctionsPrivate::functionsBackend(context, QOpenGLFunctions_4_5_CoreBackend::versionStatus());
-        if (!d) {
-            d = new QOpenGLFunctions_4_5_CoreBackend(context);
-            QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(context, QOpenGLFunctions_4_5_CoreBackend::versionStatus(), d);
-        }
         d_4_5_Core = static_cast<QOpenGLFunctions_4_5_CoreBackend*>(d);
         d->refs.ref();
 
diff --git a/src/gui/opengl/qopenglfunctions_4_5_core.h b/src/gui/opengl/qopenglfunctions_4_5_core.h
index 14614a3a5ef..b086e63917c 100644
--- a/src/gui/opengl/qopenglfunctions_4_5_core.h
+++ b/src/gui/opengl/qopenglfunctions_4_5_core.h
@@ -1,9 +1,10 @@
 /****************************************************************************
 **
 ** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
-** This file is part of the QtWidgets module of the Qt Toolkit.
+** This file is part of the QtGui module of the Qt Toolkit.
 **
 ** $QT_BEGIN_LICENSE:LGPL$
 ** Commercial License Usage
@@ -779,3276 +780,3276 @@ private:
 // OpenGL 1.0 core functions
 inline void QOpenGLFunctions_4_5_Core::glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Viewport(x, y, width, height);
+    d_1_0_Core->f.Viewport(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDepthRange(GLdouble nearVal, GLdouble farVal)
 {
-    d_1_0_Core->DepthRange(nearVal, farVal);
+    d_1_0_Core->f.DepthRange(nearVal, farVal);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Core::glIsEnabled(GLenum cap)
 {
-    return d_1_0_Core->IsEnabled(cap);
+    return d_1_0_Core->f.IsEnabled(cap);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexLevelParameteriv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameteriv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexLevelParameterfv(target, level, pname, params);
+    d_1_0_Core->f.GetTexLevelParameterfv(target, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_0_Core->GetTexParameteriv(target, pname, params);
+    d_1_0_Core->f.GetTexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
 {
-    d_1_0_Core->GetTexParameterfv(target, pname, params);
+    d_1_0_Core->f.GetTexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
 {
-    d_1_0_Core->GetTexImage(target, level, format, type, pixels);
+    d_1_0_Core->f.GetTexImage(target, level, format, type, pixels);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_5_Core::glGetString(GLenum name)
 {
-    return d_1_0_Core->GetString(name);
+    return d_1_0_Core->f.GetString(name);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetIntegerv(GLenum pname, GLint *data)
 {
-    d_1_0_Core->GetIntegerv(pname, data);
+    d_1_0_Core->f.GetIntegerv(pname, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetFloatv(GLenum pname, GLfloat *data)
 {
-    d_1_0_Core->GetFloatv(pname, data);
+    d_1_0_Core->f.GetFloatv(pname, data);
 }
 
 inline GLenum QOpenGLFunctions_4_5_Core::glGetError()
 {
-    return d_1_0_Core->GetError();
+    return d_1_0_Core->f.GetError();
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetDoublev(GLenum pname, GLdouble *data)
 {
-    d_1_0_Core->GetDoublev(pname, data);
+    d_1_0_Core->f.GetDoublev(pname, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetBooleanv(GLenum pname, GLboolean *data)
 {
-    d_1_0_Core->GetBooleanv(pname, data);
+    d_1_0_Core->f.GetBooleanv(pname, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, void *pixels)
 {
-    d_1_0_Core->ReadPixels(x, y, width, height, format, type, pixels);
+    d_1_0_Core->f.ReadPixels(x, y, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glReadBuffer(GLenum src)
 {
-    d_1_0_Core->ReadBuffer(src);
+    d_1_0_Core->f.ReadBuffer(src);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glPixelStorei(GLenum pname, GLint param)
 {
-    d_1_0_Core->PixelStorei(pname, param);
+    d_1_0_Core->f.PixelStorei(pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glPixelStoref(GLenum pname, GLfloat param)
 {
-    d_1_0_Core->PixelStoref(pname, param);
+    d_1_0_Core->f.PixelStoref(pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDepthFunc(GLenum func)
 {
-    d_1_0_Core->DepthFunc(func);
+    d_1_0_Core->f.DepthFunc(func);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
 {
-    d_1_0_Core->StencilOp(fail, zfail, zpass);
+    d_1_0_Core->f.StencilOp(fail, zfail, zpass);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glStencilFunc(GLenum func, GLint ref, GLuint mask)
 {
-    d_1_0_Core->StencilFunc(func, ref, mask);
+    d_1_0_Core->f.StencilFunc(func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glLogicOp(GLenum opcode)
 {
-    d_1_0_Core->LogicOp(opcode);
+    d_1_0_Core->f.LogicOp(opcode);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBlendFunc(GLenum sfactor, GLenum dfactor)
 {
-    d_1_0_Core->BlendFunc(sfactor, dfactor);
+    d_1_0_Core->f.BlendFunc(sfactor, dfactor);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glFlush()
 {
-    d_1_0_Core->Flush();
+    d_1_0_Core->f.Flush();
 }
 
 inline void QOpenGLFunctions_4_5_Core::glFinish()
 {
-    d_1_0_Core->Finish();
+    d_1_0_Core->f.Finish();
 }
 
 inline void QOpenGLFunctions_4_5_Core::glEnable(GLenum cap)
 {
-    d_1_0_Core->Enable(cap);
+    d_1_0_Core->f.Enable(cap);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDisable(GLenum cap)
 {
-    d_1_0_Core->Disable(cap);
+    d_1_0_Core->f.Disable(cap);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDepthMask(GLboolean flag)
 {
-    d_1_0_Core->DepthMask(flag);
+    d_1_0_Core->f.DepthMask(flag);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
 {
-    d_1_0_Core->ColorMask(red, green, blue, alpha);
+    d_1_0_Core->f.ColorMask(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glStencilMask(GLuint mask)
 {
-    d_1_0_Core->StencilMask(mask);
+    d_1_0_Core->f.StencilMask(mask);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearDepth(GLdouble depth)
 {
-    d_1_0_Core->ClearDepth(depth);
+    d_1_0_Core->f.ClearDepth(depth);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearStencil(GLint s)
 {
-    d_1_0_Core->ClearStencil(s);
+    d_1_0_Core->f.ClearStencil(s);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_0_Core->ClearColor(red, green, blue, alpha);
+    d_1_0_Core->f.ClearColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClear(GLbitfield mask)
 {
-    d_1_0_Core->Clear(mask);
+    d_1_0_Core->f.Clear(mask);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawBuffer(GLenum buf)
 {
-    d_1_0_Core->DrawBuffer(buf);
+    d_1_0_Core->f.DrawBuffer(buf);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_0_Core->TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+    d_1_0_Core->f.TexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_0_Core->TexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    d_1_0_Core->f.TexImage1D(target, level, internalformat, width, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_1_0_Core->TexParameteriv(target, pname, params);
+    d_1_0_Core->f.TexParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_1_0_Core->TexParameteri(target, pname, param);
+    d_1_0_Core->f.TexParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
 {
-    d_1_0_Core->TexParameterfv(target, pname, params);
+    d_1_0_Core->f.TexParameterfv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexParameterf(GLenum target, GLenum pname, GLfloat param)
 {
-    d_1_0_Core->TexParameterf(target, pname, param);
+    d_1_0_Core->f.TexParameterf(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_0_Core->Scissor(x, y, width, height);
+    d_1_0_Core->f.Scissor(x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glPolygonMode(GLenum face, GLenum mode)
 {
-    d_1_0_Core->PolygonMode(face, mode);
+    d_1_0_Core->f.PolygonMode(face, mode);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glPointSize(GLfloat size)
 {
-    d_1_0_Core->PointSize(size);
+    d_1_0_Core->f.PointSize(size);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glLineWidth(GLfloat width)
 {
-    d_1_0_Core->LineWidth(width);
+    d_1_0_Core->f.LineWidth(width);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glHint(GLenum target, GLenum mode)
 {
-    d_1_0_Core->Hint(target, mode);
+    d_1_0_Core->f.Hint(target, mode);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glFrontFace(GLenum mode)
 {
-    d_1_0_Core->FrontFace(mode);
+    d_1_0_Core->f.FrontFace(mode);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCullFace(GLenum mode)
 {
-    d_1_0_Core->CullFace(mode);
+    d_1_0_Core->f.CullFace(mode);
 }
 
 
 // OpenGL 1.1 core functions
 inline GLboolean QOpenGLFunctions_4_5_Core::glIsTexture(GLuint texture)
 {
-    return d_1_1_Core->IsTexture(texture);
+    return d_1_1_Core->f.IsTexture(texture);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGenTextures(GLsizei n, GLuint *textures)
 {
-    d_1_1_Core->GenTextures(n, textures);
+    d_1_1_Core->f.GenTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDeleteTextures(GLsizei n, const GLuint *textures)
 {
-    d_1_1_Core->DeleteTextures(n, textures);
+    d_1_1_Core->f.DeleteTextures(n, textures);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindTexture(GLenum target, GLuint texture)
 {
-    d_1_1_Core->BindTexture(target, texture);
+    d_1_1_Core->f.BindTexture(target, texture);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_1_Core->TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_1_1_Core->f.TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_1_Core->TexSubImage1D(target, level, xoffset, width, format, type, pixels);
+    d_1_1_Core->f.TexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_1_Core->CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+    d_1_1_Core->f.CopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_1_1_Core->CopyTexSubImage1D(target, level, xoffset, x, y, width);
+    d_1_1_Core->f.CopyTexSubImage1D(target, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
 {
-    d_1_1_Core->CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
+    d_1_1_Core->f.CopyTexImage2D(target, level, internalformat, x, y, width, height, border);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
 {
-    d_1_1_Core->CopyTexImage1D(target, level, internalformat, x, y, width, border);
+    d_1_1_Core->f.CopyTexImage1D(target, level, internalformat, x, y, width, border);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glPolygonOffset(GLfloat factor, GLfloat units)
 {
-    d_1_1_Core->PolygonOffset(factor, units);
+    d_1_1_Core->f.PolygonOffset(factor, units);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawElements(GLenum mode, GLsizei count, GLenum type, const void *indices)
 {
-    d_1_1_Core->DrawElements(mode, count, type, indices);
+    d_1_1_Core->f.DrawElements(mode, count, type, indices);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawArrays(GLenum mode, GLint first, GLsizei count)
 {
-    d_1_1_Core->DrawArrays(mode, first, count);
+    d_1_1_Core->f.DrawArrays(mode, first, count);
 }
 
 
 // OpenGL 1.2 core functions
 inline void QOpenGLFunctions_4_5_Core::glBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
 {
-    d_1_2_Core->BlendColor(red, green, blue, alpha);
+    d_1_2_Core->f.BlendColor(red, green, blue, alpha);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBlendEquation(GLenum mode)
 {
-    d_1_2_Core->BlendEquation(mode);
+    d_1_2_Core->f.BlendEquation(mode);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_1_2_Core->CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_1_2_Core->f.CopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_2_Core->TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_1_2_Core->f.TexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
 {
-    d_1_2_Core->TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    d_1_2_Core->f.TexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices)
 {
-    d_1_2_Core->DrawRangeElements(mode, start, end, count, type, indices);
+    d_1_2_Core->f.DrawRangeElements(mode, start, end, count, type, indices);
 }
 
 
 // OpenGL 1.3 core functions
 inline void QOpenGLFunctions_4_5_Core::glGetCompressedTexImage(GLenum target, GLint level, void *img)
 {
-    d_1_3_Core->GetCompressedTexImage(target, level, img);
+    d_1_3_Core->f.GetCompressedTexImage(target, level, img);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_1_3_Core->f.CompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
 {
-    d_1_3_Core->CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
+    d_1_3_Core->f.CompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glSampleCoverage(GLfloat value, GLboolean invert)
 {
-    d_1_3_Core->SampleCoverage(value, invert);
+    d_1_3_Core->f.SampleCoverage(value, invert);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glActiveTexture(GLenum texture)
 {
-    d_1_3_Core->ActiveTexture(texture);
+    d_1_3_Core->f.ActiveTexture(texture);
 }
 
 
 // OpenGL 1.4 core functions
 inline void QOpenGLFunctions_4_5_Core::glPointParameteriv(GLenum pname, const GLint *params)
 {
-    d_1_4_Core->PointParameteriv(pname, params);
+    d_1_4_Core->f.PointParameteriv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glPointParameteri(GLenum pname, GLint param)
 {
-    d_1_4_Core->PointParameteri(pname, param);
+    d_1_4_Core->f.PointParameteri(pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glPointParameterfv(GLenum pname, const GLfloat *params)
 {
-    d_1_4_Core->PointParameterfv(pname, params);
+    d_1_4_Core->f.PointParameterfv(pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glPointParameterf(GLenum pname, GLfloat param)
 {
-    d_1_4_Core->PointParameterf(pname, param);
+    d_1_4_Core->f.PointParameterf(pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawElements(mode, count, type, indices, drawcount);
+    d_1_4_Core->f.MultiDrawElements(mode, count, type, indices, drawcount);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
 {
-    d_1_4_Core->MultiDrawArrays(mode, first, count, drawcount);
+    d_1_4_Core->f.MultiDrawArrays(mode, first, count, drawcount);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
 {
-    d_1_4_Core->BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
+    d_1_4_Core->f.BlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
 }
 
 
 // OpenGL 1.5 core functions
 inline void QOpenGLFunctions_4_5_Core::glGetBufferPointerv(GLenum target, GLenum pname, void * *params)
 {
-    d_1_5_Core->GetBufferPointerv(target, pname, params);
+    d_1_5_Core->f.GetBufferPointerv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetBufferParameteriv(target, pname, params);
+    d_1_5_Core->f.GetBufferParameteriv(target, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Core::glUnmapBuffer(GLenum target)
 {
-    return d_1_5_Core->UnmapBuffer(target);
+    return d_1_5_Core->f.UnmapBuffer(target);
 }
 
 inline void * QOpenGLFunctions_4_5_Core::glMapBuffer(GLenum target, GLenum access)
 {
-    return d_1_5_Core->MapBuffer(target, access);
+    return d_1_5_Core->f.MapBuffer(target, access);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data)
 {
-    d_1_5_Core->GetBufferSubData(target, offset, size, data);
+    d_1_5_Core->f.GetBufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
 {
-    d_1_5_Core->BufferSubData(target, offset, size, data);
+    d_1_5_Core->f.BufferSubData(target, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)
 {
-    d_1_5_Core->BufferData(target, size, data, usage);
+    d_1_5_Core->f.BufferData(target, size, data, usage);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Core::glIsBuffer(GLuint buffer)
 {
-    return d_1_5_Core->IsBuffer(buffer);
+    return d_1_5_Core->f.IsBuffer(buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGenBuffers(GLsizei n, GLuint *buffers)
 {
-    d_1_5_Core->GenBuffers(n, buffers);
+    d_1_5_Core->f.GenBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDeleteBuffers(GLsizei n, const GLuint *buffers)
 {
-    d_1_5_Core->DeleteBuffers(n, buffers);
+    d_1_5_Core->f.DeleteBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindBuffer(GLenum target, GLuint buffer)
 {
-    d_1_5_Core->BindBuffer(target, buffer);
+    d_1_5_Core->f.BindBuffer(target, buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
 {
-    d_1_5_Core->GetQueryObjectuiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectuiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryObjectiv(id, pname, params);
+    d_1_5_Core->f.GetQueryObjectiv(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetQueryiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_1_5_Core->GetQueryiv(target, pname, params);
+    d_1_5_Core->f.GetQueryiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glEndQuery(GLenum target)
 {
-    d_1_5_Core->EndQuery(target);
+    d_1_5_Core->f.EndQuery(target);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBeginQuery(GLenum target, GLuint id)
 {
-    d_1_5_Core->BeginQuery(target, id);
+    d_1_5_Core->f.BeginQuery(target, id);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Core::glIsQuery(GLuint id)
 {
-    return d_1_5_Core->IsQuery(id);
+    return d_1_5_Core->f.IsQuery(id);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDeleteQueries(GLsizei n, const GLuint *ids)
 {
-    d_1_5_Core->DeleteQueries(n, ids);
+    d_1_5_Core->f.DeleteQueries(n, ids);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGenQueries(GLsizei n, GLuint *ids)
 {
-    d_1_5_Core->GenQueries(n, ids);
+    d_1_5_Core->f.GenQueries(n, ids);
 }
 
 
 // OpenGL 2.0 core functions
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void *pointer)
 {
-    d_2_0_Core->VertexAttribPointer(index, size, type, normalized, stride, pointer);
+    d_2_0_Core->f.VertexAttribPointer(index, size, type, normalized, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4usv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4usv(index, v);
+    d_2_0_Core->f.VertexAttrib4usv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4uiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4uiv(index, v);
+    d_2_0_Core->f.VertexAttrib4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4ubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4ubv(index, v);
+    d_2_0_Core->f.VertexAttrib4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4sv(index, v);
+    d_2_0_Core->f.VertexAttrib4sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4s(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)
 {
-    d_2_0_Core->VertexAttrib4s(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4s(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4iv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4iv(index, v);
+    d_2_0_Core->f.VertexAttrib4iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib4fv(index, v);
+    d_2_0_Core->f.VertexAttrib4fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
 {
-    d_2_0_Core->VertexAttrib4f(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4f(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib4dv(index, v);
+    d_2_0_Core->f.VertexAttrib4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_2_0_Core->VertexAttrib4d(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4bv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4bv(index, v);
+    d_2_0_Core->f.VertexAttrib4bv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4Nusv(GLuint index, const GLushort *v)
 {
-    d_2_0_Core->VertexAttrib4Nusv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nusv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4Nuiv(GLuint index, const GLuint *v)
 {
-    d_2_0_Core->VertexAttrib4Nuiv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nuiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4Nubv(GLuint index, const GLubyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nubv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4Nub(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)
 {
-    d_2_0_Core->VertexAttrib4Nub(index, x, y, z, w);
+    d_2_0_Core->f.VertexAttrib4Nub(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4Nsv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib4Nsv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nsv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4Niv(GLuint index, const GLint *v)
 {
-    d_2_0_Core->VertexAttrib4Niv(index, v);
+    d_2_0_Core->f.VertexAttrib4Niv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib4Nbv(GLuint index, const GLbyte *v)
 {
-    d_2_0_Core->VertexAttrib4Nbv(index, v);
+    d_2_0_Core->f.VertexAttrib4Nbv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib3sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib3sv(index, v);
+    d_2_0_Core->f.VertexAttrib3sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib3s(GLuint index, GLshort x, GLshort y, GLshort z)
 {
-    d_2_0_Core->VertexAttrib3s(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3s(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib3fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib3fv(index, v);
+    d_2_0_Core->f.VertexAttrib3fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
 {
-    d_2_0_Core->VertexAttrib3f(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3f(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib3dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib3dv(index, v);
+    d_2_0_Core->f.VertexAttrib3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_2_0_Core->VertexAttrib3d(index, x, y, z);
+    d_2_0_Core->f.VertexAttrib3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib2sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib2sv(index, v);
+    d_2_0_Core->f.VertexAttrib2sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib2s(GLuint index, GLshort x, GLshort y)
 {
-    d_2_0_Core->VertexAttrib2s(index, x, y);
+    d_2_0_Core->f.VertexAttrib2s(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib2fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib2fv(index, v);
+    d_2_0_Core->f.VertexAttrib2fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
 {
-    d_2_0_Core->VertexAttrib2f(index, x, y);
+    d_2_0_Core->f.VertexAttrib2f(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib2dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib2dv(index, v);
+    d_2_0_Core->f.VertexAttrib2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_2_0_Core->VertexAttrib2d(index, x, y);
+    d_2_0_Core->f.VertexAttrib2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib1sv(GLuint index, const GLshort *v)
 {
-    d_2_0_Core->VertexAttrib1sv(index, v);
+    d_2_0_Core->f.VertexAttrib1sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib1s(GLuint index, GLshort x)
 {
-    d_2_0_Core->VertexAttrib1s(index, x);
+    d_2_0_Core->f.VertexAttrib1s(index, x);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib1fv(GLuint index, const GLfloat *v)
 {
-    d_2_0_Core->VertexAttrib1fv(index, v);
+    d_2_0_Core->f.VertexAttrib1fv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib1f(GLuint index, GLfloat x)
 {
-    d_2_0_Core->VertexAttrib1f(index, x);
+    d_2_0_Core->f.VertexAttrib1f(index, x);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib1dv(GLuint index, const GLdouble *v)
 {
-    d_2_0_Core->VertexAttrib1dv(index, v);
+    d_2_0_Core->f.VertexAttrib1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttrib1d(GLuint index, GLdouble x)
 {
-    d_2_0_Core->VertexAttrib1d(index, x);
+    d_2_0_Core->f.VertexAttrib1d(index, x);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glValidateProgram(GLuint program)
 {
-    d_2_0_Core->ValidateProgram(program);
+    d_2_0_Core->f.ValidateProgram(program);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix4fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix3fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_0_Core->UniformMatrix2fv(location, count, transpose, value);
+    d_2_0_Core->f.UniformMatrix2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform4iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform4iv(location, count, value);
+    d_2_0_Core->f.Uniform4iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform3iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform3iv(location, count, value);
+    d_2_0_Core->f.Uniform3iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform2iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform2iv(location, count, value);
+    d_2_0_Core->f.Uniform2iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform1iv(GLint location, GLsizei count, const GLint *value)
 {
-    d_2_0_Core->Uniform1iv(location, count, value);
+    d_2_0_Core->f.Uniform1iv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform4fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform4fv(location, count, value);
+    d_2_0_Core->f.Uniform4fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform3fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform3fv(location, count, value);
+    d_2_0_Core->f.Uniform3fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform2fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform2fv(location, count, value);
+    d_2_0_Core->f.Uniform2fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform1fv(GLint location, GLsizei count, const GLfloat *value)
 {
-    d_2_0_Core->Uniform1fv(location, count, value);
+    d_2_0_Core->f.Uniform1fv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_2_0_Core->Uniform4i(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4i(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_2_0_Core->Uniform3i(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3i(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform2i(GLint location, GLint v0, GLint v1)
 {
-    d_2_0_Core->Uniform2i(location, v0, v1);
+    d_2_0_Core->f.Uniform2i(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform1i(GLint location, GLint v0)
 {
-    d_2_0_Core->Uniform1i(location, v0);
+    d_2_0_Core->f.Uniform1i(location, v0);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_2_0_Core->Uniform4f(location, v0, v1, v2, v3);
+    d_2_0_Core->f.Uniform4f(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_2_0_Core->Uniform3f(location, v0, v1, v2);
+    d_2_0_Core->f.Uniform3f(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform2f(GLint location, GLfloat v0, GLfloat v1)
 {
-    d_2_0_Core->Uniform2f(location, v0, v1);
+    d_2_0_Core->f.Uniform2f(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform1f(GLint location, GLfloat v0)
 {
-    d_2_0_Core->Uniform1f(location, v0);
+    d_2_0_Core->f.Uniform1f(location, v0);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUseProgram(GLuint program)
 {
-    d_2_0_Core->UseProgram(program);
+    d_2_0_Core->f.UseProgram(program);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glShaderSource(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length)
 {
-    d_2_0_Core->ShaderSource(shader, count, string, length);
+    d_2_0_Core->f.ShaderSource(shader, count, string, length);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glLinkProgram(GLuint program)
 {
-    d_2_0_Core->LinkProgram(program);
+    d_2_0_Core->f.LinkProgram(program);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Core::glIsShader(GLuint shader)
 {
-    return d_2_0_Core->IsShader(shader);
+    return d_2_0_Core->f.IsShader(shader);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Core::glIsProgram(GLuint program)
 {
-    return d_2_0_Core->IsProgram(program);
+    return d_2_0_Core->f.IsProgram(program);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetVertexAttribPointerv(GLuint index, GLenum pname, void * *pointer)
 {
-    d_2_0_Core->GetVertexAttribPointerv(index, pname, pointer);
+    d_2_0_Core->f.GetVertexAttribPointerv(index, pname, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetVertexAttribiv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
 {
-    d_2_0_Core->GetVertexAttribfv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribfv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_2_0_Core->GetVertexAttribdv(index, pname, params);
+    d_2_0_Core->f.GetVertexAttribdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetUniformiv(GLuint program, GLint location, GLint *params)
 {
-    d_2_0_Core->GetUniformiv(program, location, params);
+    d_2_0_Core->f.GetUniformiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetUniformfv(GLuint program, GLint location, GLfloat *params)
 {
-    d_2_0_Core->GetUniformfv(program, location, params);
+    d_2_0_Core->f.GetUniformfv(program, location, params);
 }
 
 inline GLint QOpenGLFunctions_4_5_Core::glGetUniformLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetUniformLocation(program, name);
+    return d_2_0_Core->f.GetUniformLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
 {
-    d_2_0_Core->GetShaderSource(shader, bufSize, length, source);
+    d_2_0_Core->f.GetShaderSource(shader, bufSize, length, source);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetShaderInfoLog(shader, bufSize, length, infoLog);
+    d_2_0_Core->f.GetShaderInfoLog(shader, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetShaderiv(GLuint shader, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetShaderiv(shader, pname, params);
+    d_2_0_Core->f.GetShaderiv(shader, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_2_0_Core->GetProgramInfoLog(program, bufSize, length, infoLog);
+    d_2_0_Core->f.GetProgramInfoLog(program, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetProgramiv(GLuint program, GLenum pname, GLint *params)
 {
-    d_2_0_Core->GetProgramiv(program, pname, params);
+    d_2_0_Core->f.GetProgramiv(program, pname, params);
 }
 
 inline GLint QOpenGLFunctions_4_5_Core::glGetAttribLocation(GLuint program, const GLchar *name)
 {
-    return d_2_0_Core->GetAttribLocation(program, name);
+    return d_2_0_Core->f.GetAttribLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
 {
-    d_2_0_Core->GetAttachedShaders(program, maxCount, count, shaders);
+    d_2_0_Core->f.GetAttachedShaders(program, maxCount, count, shaders);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveUniform(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveUniform(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
 {
-    d_2_0_Core->GetActiveAttrib(program, index, bufSize, length, size, type, name);
+    d_2_0_Core->f.GetActiveAttrib(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glEnableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->EnableVertexAttribArray(index);
+    d_2_0_Core->f.EnableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDisableVertexAttribArray(GLuint index)
 {
-    d_2_0_Core->DisableVertexAttribArray(index);
+    d_2_0_Core->f.DisableVertexAttribArray(index);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDetachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->DetachShader(program, shader);
+    d_2_0_Core->f.DetachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDeleteShader(GLuint shader)
 {
-    d_2_0_Core->DeleteShader(shader);
+    d_2_0_Core->f.DeleteShader(shader);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDeleteProgram(GLuint program)
 {
-    d_2_0_Core->DeleteProgram(program);
+    d_2_0_Core->f.DeleteProgram(program);
 }
 
 inline GLuint QOpenGLFunctions_4_5_Core::glCreateShader(GLenum type)
 {
-    return d_2_0_Core->CreateShader(type);
+    return d_2_0_Core->f.CreateShader(type);
 }
 
 inline GLuint QOpenGLFunctions_4_5_Core::glCreateProgram()
 {
-    return d_2_0_Core->CreateProgram();
+    return d_2_0_Core->f.CreateProgram();
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCompileShader(GLuint shader)
 {
-    d_2_0_Core->CompileShader(shader);
+    d_2_0_Core->f.CompileShader(shader);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
 {
-    d_2_0_Core->BindAttribLocation(program, index, name);
+    d_2_0_Core->f.BindAttribLocation(program, index, name);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glAttachShader(GLuint program, GLuint shader)
 {
-    d_2_0_Core->AttachShader(program, shader);
+    d_2_0_Core->f.AttachShader(program, shader);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glStencilMaskSeparate(GLenum face, GLuint mask)
 {
-    d_2_0_Core->StencilMaskSeparate(face, mask);
+    d_2_0_Core->f.StencilMaskSeparate(face, mask);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
 {
-    d_2_0_Core->StencilFuncSeparate(face, func, ref, mask);
+    d_2_0_Core->f.StencilFuncSeparate(face, func, ref, mask);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
 {
-    d_2_0_Core->StencilOpSeparate(face, sfail, dpfail, dppass);
+    d_2_0_Core->f.StencilOpSeparate(face, sfail, dpfail, dppass);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawBuffers(GLsizei n, const GLenum *bufs)
 {
-    d_2_0_Core->DrawBuffers(n, bufs);
+    d_2_0_Core->f.DrawBuffers(n, bufs);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
 {
-    d_2_0_Core->BlendEquationSeparate(modeRGB, modeAlpha);
+    d_2_0_Core->f.BlendEquationSeparate(modeRGB, modeAlpha);
 }
 
 
 // OpenGL 2.1 core functions
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x3fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix4x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix4x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x4fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x4fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix3x2fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix3x2fv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_2_1_Core->UniformMatrix2x3fv(location, count, transpose, value);
+    d_2_1_Core->f.UniformMatrix2x3fv(location, count, transpose, value);
 }
 
 
 // OpenGL 3.0 core functions
 inline GLboolean QOpenGLFunctions_4_5_Core::glIsVertexArray(GLuint array)
 {
-    return d_3_0_Core->IsVertexArray(array);
+    return d_3_0_Core->f.IsVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGenVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_3_0_Core->GenVertexArrays(n, arrays);
+    d_3_0_Core->f.GenVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDeleteVertexArrays(GLsizei n, const GLuint *arrays)
 {
-    d_3_0_Core->DeleteVertexArrays(n, arrays);
+    d_3_0_Core->f.DeleteVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindVertexArray(GLuint array)
 {
-    d_3_0_Core->BindVertexArray(array);
+    d_3_0_Core->f.BindVertexArray(array);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
 {
-    d_3_0_Core->FlushMappedBufferRange(target, offset, length);
+    d_3_0_Core->f.FlushMappedBufferRange(target, offset, length);
 }
 
 inline void * QOpenGLFunctions_4_5_Core::glMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
 {
-    return d_3_0_Core->MapBufferRange(target, offset, length, access);
+    return d_3_0_Core->f.MapBufferRange(target, offset, length, access);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_3_0_Core->FramebufferTextureLayer(target, attachment, texture, level, layer);
+    d_3_0_Core->f.FramebufferTextureLayer(target, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorageMultisample(target, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_3_0_Core->BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_3_0_Core->f.BlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGenerateMipmap(GLenum target)
 {
-    d_3_0_Core->GenerateMipmap(target);
+    d_3_0_Core->f.GenerateMipmap(target);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
+    d_3_0_Core->f.GetFramebufferAttachmentParameteriv(target, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_3_0_Core->FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
+    d_3_0_Core->f.FramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
 {
-    d_3_0_Core->FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    d_3_0_Core->f.FramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture2D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture2D(target, attachment, textarget, texture, level);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
 {
-    d_3_0_Core->FramebufferTexture1D(target, attachment, textarget, texture, level);
+    d_3_0_Core->f.FramebufferTexture1D(target, attachment, textarget, texture, level);
 }
 
 inline GLenum QOpenGLFunctions_4_5_Core::glCheckFramebufferStatus(GLenum target)
 {
-    return d_3_0_Core->CheckFramebufferStatus(target);
+    return d_3_0_Core->f.CheckFramebufferStatus(target);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGenFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_3_0_Core->GenFramebuffers(n, framebuffers);
+    d_3_0_Core->f.GenFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
 {
-    d_3_0_Core->DeleteFramebuffers(n, framebuffers);
+    d_3_0_Core->f.DeleteFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindFramebuffer(GLenum target, GLuint framebuffer)
 {
-    d_3_0_Core->BindFramebuffer(target, framebuffer);
+    d_3_0_Core->f.BindFramebuffer(target, framebuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Core::glIsFramebuffer(GLuint framebuffer)
 {
-    return d_3_0_Core->IsFramebuffer(framebuffer);
+    return d_3_0_Core->f.IsFramebuffer(framebuffer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetRenderbufferParameteriv(target, pname, params);
+    d_3_0_Core->f.GetRenderbufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_3_0_Core->RenderbufferStorage(target, internalformat, width, height);
+    d_3_0_Core->f.RenderbufferStorage(target, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_3_0_Core->GenRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.GenRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
 {
-    d_3_0_Core->DeleteRenderbuffers(n, renderbuffers);
+    d_3_0_Core->f.DeleteRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindRenderbuffer(GLenum target, GLuint renderbuffer)
 {
-    d_3_0_Core->BindRenderbuffer(target, renderbuffer);
+    d_3_0_Core->f.BindRenderbuffer(target, renderbuffer);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Core::glIsRenderbuffer(GLuint renderbuffer)
 {
-    return d_3_0_Core->IsRenderbuffer(renderbuffer);
+    return d_3_0_Core->f.IsRenderbuffer(renderbuffer);
 }
 
 inline const GLubyte * QOpenGLFunctions_4_5_Core::glGetStringi(GLenum name, GLuint index)
 {
-    return d_3_0_Core->GetStringi(name, index);
+    return d_3_0_Core->f.GetStringi(name, index);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
 {
-    d_3_0_Core->ClearBufferfi(buffer, drawbuffer, depth, stencil);
+    d_3_0_Core->f.ClearBufferfi(buffer, drawbuffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_3_0_Core->ClearBufferfv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferfv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_3_0_Core->ClearBufferuiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferuiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_3_0_Core->ClearBufferiv(buffer, drawbuffer, value);
+    d_3_0_Core->f.ClearBufferiv(buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetTexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetTexParameterIiv(target, pname, params);
+    d_3_0_Core->f.GetTexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
 {
-    d_3_0_Core->TexParameterIuiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIuiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
 {
-    d_3_0_Core->TexParameterIiv(target, pname, params);
+    d_3_0_Core->f.TexParameterIiv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform4uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform4uiv(location, count, value);
+    d_3_0_Core->f.Uniform4uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform3uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform3uiv(location, count, value);
+    d_3_0_Core->f.Uniform3uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform2uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform2uiv(location, count, value);
+    d_3_0_Core->f.Uniform2uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform1uiv(GLint location, GLsizei count, const GLuint *value)
 {
-    d_3_0_Core->Uniform1uiv(location, count, value);
+    d_3_0_Core->f.Uniform1uiv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_3_0_Core->Uniform4ui(location, v0, v1, v2, v3);
+    d_3_0_Core->f.Uniform4ui(location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_3_0_Core->Uniform3ui(location, v0, v1, v2);
+    d_3_0_Core->f.Uniform3ui(location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform2ui(GLint location, GLuint v0, GLuint v1)
 {
-    d_3_0_Core->Uniform2ui(location, v0, v1);
+    d_3_0_Core->f.Uniform2ui(location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform1ui(GLint location, GLuint v0)
 {
-    d_3_0_Core->Uniform1ui(location, v0);
+    d_3_0_Core->f.Uniform1ui(location, v0);
 }
 
 inline GLint QOpenGLFunctions_4_5_Core::glGetFragDataLocation(GLuint program, const GLchar *name)
 {
-    return d_3_0_Core->GetFragDataLocation(program, name);
+    return d_3_0_Core->f.GetFragDataLocation(program, name);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
 {
-    d_3_0_Core->BindFragDataLocation(program, color, name);
+    d_3_0_Core->f.BindFragDataLocation(program, color, name);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetUniformuiv(GLuint program, GLint location, GLuint *params)
 {
-    d_3_0_Core->GetUniformuiv(program, location, params);
+    d_3_0_Core->f.GetUniformuiv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI4usv(GLuint index, const GLushort *v)
 {
-    d_3_0_Core->VertexAttribI4usv(index, v);
+    d_3_0_Core->f.VertexAttribI4usv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI4ubv(GLuint index, const GLubyte *v)
 {
-    d_3_0_Core->VertexAttribI4ubv(index, v);
+    d_3_0_Core->f.VertexAttribI4ubv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI4sv(GLuint index, const GLshort *v)
 {
-    d_3_0_Core->VertexAttribI4sv(index, v);
+    d_3_0_Core->f.VertexAttribI4sv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI4bv(GLuint index, const GLbyte *v)
 {
-    d_3_0_Core->VertexAttribI4bv(index, v);
+    d_3_0_Core->f.VertexAttribI4bv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI4uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI4uiv(index, v);
+    d_3_0_Core->f.VertexAttribI4uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI3uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI3uiv(index, v);
+    d_3_0_Core->f.VertexAttribI3uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI2uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI2uiv(index, v);
+    d_3_0_Core->f.VertexAttribI2uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI1uiv(GLuint index, const GLuint *v)
 {
-    d_3_0_Core->VertexAttribI1uiv(index, v);
+    d_3_0_Core->f.VertexAttribI1uiv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI4iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI4iv(index, v);
+    d_3_0_Core->f.VertexAttribI4iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI3iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI3iv(index, v);
+    d_3_0_Core->f.VertexAttribI3iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI2iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI2iv(index, v);
+    d_3_0_Core->f.VertexAttribI2iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI1iv(GLuint index, const GLint *v)
 {
-    d_3_0_Core->VertexAttribI1iv(index, v);
+    d_3_0_Core->f.VertexAttribI1iv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
 {
-    d_3_0_Core->VertexAttribI4ui(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4ui(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
 {
-    d_3_0_Core->VertexAttribI3ui(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3ui(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
 {
-    d_3_0_Core->VertexAttribI2ui(index, x, y);
+    d_3_0_Core->f.VertexAttribI2ui(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI1ui(GLuint index, GLuint x)
 {
-    d_3_0_Core->VertexAttribI1ui(index, x);
+    d_3_0_Core->f.VertexAttribI1ui(index, x);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
 {
-    d_3_0_Core->VertexAttribI4i(index, x, y, z, w);
+    d_3_0_Core->f.VertexAttribI4i(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
 {
-    d_3_0_Core->VertexAttribI3i(index, x, y, z);
+    d_3_0_Core->f.VertexAttribI3i(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI2i(GLuint index, GLint x, GLint y)
 {
-    d_3_0_Core->VertexAttribI2i(index, x, y);
+    d_3_0_Core->f.VertexAttribI2i(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribI1i(GLuint index, GLint x)
 {
-    d_3_0_Core->VertexAttribI1i(index, x);
+    d_3_0_Core->f.VertexAttribI1i(index, x);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
 {
-    d_3_0_Core->GetVertexAttribIuiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIuiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
 {
-    d_3_0_Core->GetVertexAttribIiv(index, pname, params);
+    d_3_0_Core->f.GetVertexAttribIiv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
-    d_3_0_Core->VertexAttribIPointer(index, size, type, stride, pointer);
+    d_3_0_Core->f.VertexAttribIPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glEndConditionalRender()
 {
-    d_3_0_Core->EndConditionalRender();
+    d_3_0_Core->f.EndConditionalRender();
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBeginConditionalRender(GLuint id, GLenum mode)
 {
-    d_3_0_Core->BeginConditionalRender(id, mode);
+    d_3_0_Core->f.BeginConditionalRender(id, mode);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClampColor(GLenum target, GLenum clamp)
 {
-    d_3_0_Core->ClampColor(target, clamp);
+    d_3_0_Core->f.ClampColor(target, clamp);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
 {
-    d_3_0_Core->GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
+    d_3_0_Core->f.GetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const *varyings, GLenum bufferMode)
 {
-    d_3_0_Core->TransformFeedbackVaryings(program, count, varyings, bufferMode);
+    d_3_0_Core->f.TransformFeedbackVaryings(program, count, varyings, bufferMode);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindBufferBase(GLenum target, GLuint index, GLuint buffer)
 {
-    d_3_0_Core->BindBufferBase(target, index, buffer);
+    d_3_0_Core->f.BindBufferBase(target, index, buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_3_0_Core->BindBufferRange(target, index, buffer, offset, size);
+    d_3_0_Core->f.BindBufferRange(target, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glEndTransformFeedback()
 {
-    d_3_0_Core->EndTransformFeedback();
+    d_3_0_Core->f.EndTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBeginTransformFeedback(GLenum primitiveMode)
 {
-    d_3_0_Core->BeginTransformFeedback(primitiveMode);
+    d_3_0_Core->f.BeginTransformFeedback(primitiveMode);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Core::glIsEnabledi(GLenum target, GLuint index)
 {
-    return d_3_0_Core->IsEnabledi(target, index);
+    return d_3_0_Core->f.IsEnabledi(target, index);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDisablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Disablei(target, index);
+    d_3_0_Core->f.Disablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glEnablei(GLenum target, GLuint index)
 {
-    d_3_0_Core->Enablei(target, index);
+    d_3_0_Core->f.Enablei(target, index);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetIntegeri_v(GLenum target, GLuint index, GLint *data)
 {
-    d_3_0_Core->GetIntegeri_v(target, index, data);
+    d_3_0_Core->f.GetIntegeri_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
 {
-    d_3_0_Core->GetBooleani_v(target, index, data);
+    d_3_0_Core->f.GetBooleani_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glColorMaski(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)
 {
-    d_3_0_Core->ColorMaski(index, r, g, b, a);
+    d_3_0_Core->f.ColorMaski(index, r, g, b, a);
 }
 
 
 // OpenGL 3.1 core functions
 inline void QOpenGLFunctions_4_5_Core::glUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
 {
-    d_3_1_Core->UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
+    d_3_1_Core->f.UniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
 {
-    d_3_1_Core->GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
+    d_3_1_Core->f.GetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
+    d_3_1_Core->f.GetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
 }
 
 inline GLuint QOpenGLFunctions_4_5_Core::glGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
 {
-    return d_3_1_Core->GetUniformBlockIndex(program, uniformBlockName);
+    return d_3_1_Core->f.GetUniformBlockIndex(program, uniformBlockName);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
 {
-    d_3_1_Core->GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
+    d_3_1_Core->f.GetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
 {
-    d_3_1_Core->GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
+    d_3_1_Core->f.GetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const *uniformNames, GLuint *uniformIndices)
 {
-    d_3_1_Core->GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
+    d_3_1_Core->f.GetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
 {
-    d_3_1_Core->CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
+    d_3_1_Core->f.CopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glPrimitiveRestartIndex(GLuint index)
 {
-    d_3_1_Core->PrimitiveRestartIndex(index);
+    d_3_1_Core->f.PrimitiveRestartIndex(index);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
 {
-    d_3_1_Core->TexBuffer(target, internalformat, buffer);
+    d_3_1_Core->f.TexBuffer(target, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount)
 {
-    d_3_1_Core->DrawElementsInstanced(mode, count, type, indices, instancecount);
+    d_3_1_Core->f.DrawElementsInstanced(mode, count, type, indices, instancecount);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
 {
-    d_3_1_Core->DrawArraysInstanced(mode, first, count, instancecount);
+    d_3_1_Core->f.DrawArraysInstanced(mode, first, count, instancecount);
 }
 
 
 // OpenGL 3.2 core functions
 inline void QOpenGLFunctions_4_5_Core::glSampleMaski(GLuint maskNumber, GLbitfield mask)
 {
-    d_3_2_Core->SampleMaski(maskNumber, mask);
+    d_3_2_Core->f.SampleMaski(maskNumber, mask);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
 {
-    d_3_2_Core->GetMultisamplefv(pname, index, val);
+    d_3_2_Core->f.GetMultisamplefv(pname, index, val);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_3_2_Core->f.TexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_3_2_Core->TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_3_2_Core->f.TexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
 {
-    d_3_2_Core->FramebufferTexture(target, attachment, texture, level);
+    d_3_2_Core->f.FramebufferTexture(target, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
 {
-    d_3_2_Core->GetBufferParameteri64v(target, pname, params);
+    d_3_2_Core->f.GetBufferParameteri64v(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64i_v(target, index, data);
+    d_3_2_Core->f.GetInteger64i_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
 {
-    d_3_2_Core->GetSynciv(sync, pname, bufSize, length, values);
+    d_3_2_Core->f.GetSynciv(sync, pname, bufSize, length, values);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetInteger64v(GLenum pname, GLint64 *data)
 {
-    d_3_2_Core->GetInteger64v(pname, data);
+    d_3_2_Core->f.GetInteger64v(pname, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    d_3_2_Core->WaitSync(sync, flags, timeout);
+    d_3_2_Core->f.WaitSync(sync, flags, timeout);
 }
 
 inline GLenum QOpenGLFunctions_4_5_Core::glClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
 {
-    return d_3_2_Core->ClientWaitSync(sync, flags, timeout);
+    return d_3_2_Core->f.ClientWaitSync(sync, flags, timeout);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDeleteSync(GLsync sync)
 {
-    d_3_2_Core->DeleteSync(sync);
+    d_3_2_Core->f.DeleteSync(sync);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Core::glIsSync(GLsync sync)
 {
-    return d_3_2_Core->IsSync(sync);
+    return d_3_2_Core->f.IsSync(sync);
 }
 
 inline GLsync QOpenGLFunctions_4_5_Core::glFenceSync(GLenum condition, GLbitfield flags)
 {
-    return d_3_2_Core->FenceSync(condition, flags);
+    return d_3_2_Core->f.FenceSync(condition, flags);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProvokingVertex(GLenum mode)
 {
-    d_3_2_Core->ProvokingVertex(mode);
+    d_3_2_Core->f.ProvokingVertex(mode);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex)
 {
-    d_3_2_Core->MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
+    d_3_2_Core->f.MultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
+    d_3_2_Core->f.DrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
 {
-    d_3_2_Core->DrawElementsBaseVertex(mode, count, type, indices, basevertex);
+    d_3_2_Core->f.DrawElementsBaseVertex(mode, count, type, indices, basevertex);
 }
 
 
 // OpenGL 3.3 core functions
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribP4uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP4uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribP4ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP4ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP4ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribP3uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP3uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribP3ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP3ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP3ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribP2uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP2uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribP2ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP2ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP2ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribP1uiv(GLuint index, GLenum type, GLboolean normalized, const GLuint *value)
 {
-    d_3_3_Core->VertexAttribP1uiv(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1uiv(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribP1ui(GLuint index, GLenum type, GLboolean normalized, GLuint value)
 {
-    d_3_3_Core->VertexAttribP1ui(index, type, normalized, value);
+    d_3_3_Core->f.VertexAttribP1ui(index, type, normalized, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribDivisor(GLuint index, GLuint divisor)
 {
-    d_3_3_Core->VertexAttribDivisor(index, divisor);
+    d_3_3_Core->f.VertexAttribDivisor(index, divisor);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
 {
-    d_3_3_Core->GetQueryObjectui64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjectui64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
 {
-    d_3_3_Core->GetQueryObjecti64v(id, pname, params);
+    d_3_3_Core->f.GetQueryObjecti64v(id, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glQueryCounter(GLuint id, GLenum target)
 {
-    d_3_3_Core->QueryCounter(id, target);
+    d_3_3_Core->f.QueryCounter(id, target);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
 {
-    d_3_3_Core->GetSamplerParameterIuiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIuiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
 {
-    d_3_3_Core->GetSamplerParameterfv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterfv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameterIiv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameterIiv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
 {
-    d_3_3_Core->GetSamplerParameteriv(sampler, pname, params);
+    d_3_3_Core->f.GetSamplerParameteriv(sampler, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
 {
-    d_3_3_Core->SamplerParameterIuiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIuiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameterIiv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterIiv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
 {
-    d_3_3_Core->SamplerParameterfv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterfv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
 {
-    d_3_3_Core->SamplerParameterf(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameterf(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
 {
-    d_3_3_Core->SamplerParameteriv(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteriv(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
 {
-    d_3_3_Core->SamplerParameteri(sampler, pname, param);
+    d_3_3_Core->f.SamplerParameteri(sampler, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindSampler(GLuint unit, GLuint sampler)
 {
-    d_3_3_Core->BindSampler(unit, sampler);
+    d_3_3_Core->f.BindSampler(unit, sampler);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Core::glIsSampler(GLuint sampler)
 {
-    return d_3_3_Core->IsSampler(sampler);
+    return d_3_3_Core->f.IsSampler(sampler);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDeleteSamplers(GLsizei count, const GLuint *samplers)
 {
-    d_3_3_Core->DeleteSamplers(count, samplers);
+    d_3_3_Core->f.DeleteSamplers(count, samplers);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGenSamplers(GLsizei count, GLuint *samplers)
 {
-    d_3_3_Core->GenSamplers(count, samplers);
+    d_3_3_Core->f.GenSamplers(count, samplers);
 }
 
 inline GLint QOpenGLFunctions_4_5_Core::glGetFragDataIndex(GLuint program, const GLchar *name)
 {
-    return d_3_3_Core->GetFragDataIndex(program, name);
+    return d_3_3_Core->f.GetFragDataIndex(program, name);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
 {
-    d_3_3_Core->BindFragDataLocationIndexed(program, colorNumber, index, name);
+    d_3_3_Core->f.BindFragDataLocationIndexed(program, colorNumber, index, name);
 }
 
 
 // OpenGL 4.0 core functions
 inline void QOpenGLFunctions_4_5_Core::glGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
 {
-    d_4_0_Core->GetQueryIndexediv(target, index, pname, params);
+    d_4_0_Core->f.GetQueryIndexediv(target, index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glEndQueryIndexed(GLenum target, GLuint index)
 {
-    d_4_0_Core->EndQueryIndexed(target, index);
+    d_4_0_Core->f.EndQueryIndexed(target, index);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
 {
-    d_4_0_Core->BeginQueryIndexed(target, index, id);
+    d_4_0_Core->f.BeginQueryIndexed(target, index, id);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
 {
-    d_4_0_Core->DrawTransformFeedbackStream(mode, id, stream);
+    d_4_0_Core->f.DrawTransformFeedbackStream(mode, id, stream);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawTransformFeedback(GLenum mode, GLuint id)
 {
-    d_4_0_Core->DrawTransformFeedback(mode, id);
+    d_4_0_Core->f.DrawTransformFeedback(mode, id);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glResumeTransformFeedback()
 {
-    d_4_0_Core->ResumeTransformFeedback();
+    d_4_0_Core->f.ResumeTransformFeedback();
 }
 
 inline void QOpenGLFunctions_4_5_Core::glPauseTransformFeedback()
 {
-    d_4_0_Core->PauseTransformFeedback();
+    d_4_0_Core->f.PauseTransformFeedback();
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Core::glIsTransformFeedback(GLuint id)
 {
-    return d_4_0_Core->IsTransformFeedback(id);
+    return d_4_0_Core->f.IsTransformFeedback(id);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGenTransformFeedbacks(GLsizei n, GLuint *ids)
 {
-    d_4_0_Core->GenTransformFeedbacks(n, ids);
+    d_4_0_Core->f.GenTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
 {
-    d_4_0_Core->DeleteTransformFeedbacks(n, ids);
+    d_4_0_Core->f.DeleteTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindTransformFeedback(GLenum target, GLuint id)
 {
-    d_4_0_Core->BindTransformFeedback(target, id);
+    d_4_0_Core->f.BindTransformFeedback(target, id);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glPatchParameterfv(GLenum pname, const GLfloat *values)
 {
-    d_4_0_Core->PatchParameterfv(pname, values);
+    d_4_0_Core->f.PatchParameterfv(pname, values);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glPatchParameteri(GLenum pname, GLint value)
 {
-    d_4_0_Core->PatchParameteri(pname, value);
+    d_4_0_Core->f.PatchParameteri(pname, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetProgramStageiv(program, shadertype, pname, values);
+    d_4_0_Core->f.GetProgramStageiv(program, shadertype, pname, values);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
 {
-    d_4_0_Core->GetUniformSubroutineuiv(shadertype, location, params);
+    d_4_0_Core->f.GetUniformSubroutineuiv(shadertype, location, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
 {
-    d_4_0_Core->UniformSubroutinesuiv(shadertype, count, indices);
+    d_4_0_Core->f.UniformSubroutinesuiv(shadertype, count, indices);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
 {
-    d_4_0_Core->GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
+    d_4_0_Core->f.GetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
 {
-    d_4_0_Core->GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
+    d_4_0_Core->f.GetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
 }
 
 inline GLuint QOpenGLFunctions_4_5_Core::glGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineIndex(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineIndex(program, shadertype, name);
 }
 
 inline GLint QOpenGLFunctions_4_5_Core::glGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
 {
-    return d_4_0_Core->GetSubroutineUniformLocation(program, shadertype, name);
+    return d_4_0_Core->f.GetSubroutineUniformLocation(program, shadertype, name);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetUniformdv(GLuint program, GLint location, GLdouble *params)
 {
-    d_4_0_Core->GetUniformdv(program, location, params);
+    d_4_0_Core->f.GetUniformdv(program, location, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3x2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3x2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2x3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2x3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix4dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix4dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix4dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix3dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix3dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix3dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniformMatrix2dv(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_0_Core->UniformMatrix2dv(location, count, transpose, value);
+    d_4_0_Core->f.UniformMatrix2dv(location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform4dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform4dv(location, count, value);
+    d_4_0_Core->f.Uniform4dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform3dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform3dv(location, count, value);
+    d_4_0_Core->f.Uniform3dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform2dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform2dv(location, count, value);
+    d_4_0_Core->f.Uniform2dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform1dv(GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_0_Core->Uniform1dv(location, count, value);
+    d_4_0_Core->f.Uniform1dv(location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_0_Core->Uniform4d(location, x, y, z, w);
+    d_4_0_Core->f.Uniform4d(location, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_0_Core->Uniform3d(location, x, y, z);
+    d_4_0_Core->f.Uniform3d(location, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform2d(GLint location, GLdouble x, GLdouble y)
 {
-    d_4_0_Core->Uniform2d(location, x, y);
+    d_4_0_Core->f.Uniform2d(location, x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUniform1d(GLint location, GLdouble x)
 {
-    d_4_0_Core->Uniform1d(location, x);
+    d_4_0_Core->f.Uniform1d(location, x);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
 {
-    d_4_0_Core->DrawElementsIndirect(mode, type, indirect);
+    d_4_0_Core->f.DrawElementsIndirect(mode, type, indirect);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawArraysIndirect(GLenum mode, const void *indirect)
 {
-    d_4_0_Core->DrawArraysIndirect(mode, indirect);
+    d_4_0_Core->f.DrawArraysIndirect(mode, indirect);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
 {
-    d_4_0_Core->BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
+    d_4_0_Core->f.BlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBlendFunci(GLuint buf, GLenum src, GLenum dst)
 {
-    d_4_0_Core->BlendFunci(buf, src, dst);
+    d_4_0_Core->f.BlendFunci(buf, src, dst);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
 {
-    d_4_0_Core->BlendEquationSeparatei(buf, modeRGB, modeAlpha);
+    d_4_0_Core->f.BlendEquationSeparatei(buf, modeRGB, modeAlpha);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBlendEquationi(GLuint buf, GLenum mode)
 {
-    d_4_0_Core->BlendEquationi(buf, mode);
+    d_4_0_Core->f.BlendEquationi(buf, mode);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glMinSampleShading(GLfloat value)
 {
-    d_4_0_Core->MinSampleShading(value);
+    d_4_0_Core->f.MinSampleShading(value);
 }
 
 
 // OpenGL 4.1 core functions
 inline void QOpenGLFunctions_4_5_Core::glGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
 {
-    d_4_1_Core->GetDoublei_v(target, index, data);
+    d_4_1_Core->f.GetDoublei_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetFloati_v(GLenum target, GLuint index, GLfloat *data)
 {
-    d_4_1_Core->GetFloati_v(target, index, data);
+    d_4_1_Core->f.GetFloati_v(target, index, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
 {
-    d_4_1_Core->DepthRangeIndexed(index, n, f);
+    d_4_1_Core->f.DepthRangeIndexed(index, n, f);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
 {
-    d_4_1_Core->DepthRangeArrayv(first, count, v);
+    d_4_1_Core->f.DepthRangeArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glScissorIndexedv(GLuint index, const GLint *v)
 {
-    d_4_1_Core->ScissorIndexedv(index, v);
+    d_4_1_Core->f.ScissorIndexedv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
 {
-    d_4_1_Core->ScissorIndexed(index, left, bottom, width, height);
+    d_4_1_Core->f.ScissorIndexed(index, left, bottom, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glScissorArrayv(GLuint first, GLsizei count, const GLint *v)
 {
-    d_4_1_Core->ScissorArrayv(first, count, v);
+    d_4_1_Core->f.ScissorArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glViewportIndexedfv(GLuint index, const GLfloat *v)
 {
-    d_4_1_Core->ViewportIndexedfv(index, v);
+    d_4_1_Core->f.ViewportIndexedfv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
 {
-    d_4_1_Core->ViewportIndexedf(index, x, y, w, h);
+    d_4_1_Core->f.ViewportIndexedf(index, x, y, w, h);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
 {
-    d_4_1_Core->ViewportArrayv(first, count, v);
+    d_4_1_Core->f.ViewportArrayv(first, count, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
 {
-    d_4_1_Core->GetVertexAttribLdv(index, pname, params);
+    d_4_1_Core->f.GetVertexAttribLdv(index, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
 {
-    d_4_1_Core->VertexAttribLPointer(index, size, type, stride, pointer);
+    d_4_1_Core->f.VertexAttribLPointer(index, size, type, stride, pointer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribL4dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL4dv(index, v);
+    d_4_1_Core->f.VertexAttribL4dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribL3dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL3dv(index, v);
+    d_4_1_Core->f.VertexAttribL3dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribL2dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL2dv(index, v);
+    d_4_1_Core->f.VertexAttribL2dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribL1dv(GLuint index, const GLdouble *v)
 {
-    d_4_1_Core->VertexAttribL1dv(index, v);
+    d_4_1_Core->f.VertexAttribL1dv(index, v);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
 {
-    d_4_1_Core->VertexAttribL4d(index, x, y, z, w);
+    d_4_1_Core->f.VertexAttribL4d(index, x, y, z, w);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
 {
-    d_4_1_Core->VertexAttribL3d(index, x, y, z);
+    d_4_1_Core->f.VertexAttribL3d(index, x, y, z);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
 {
-    d_4_1_Core->VertexAttribL2d(index, x, y);
+    d_4_1_Core->f.VertexAttribL2d(index, x, y);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribL1d(GLuint index, GLdouble x)
 {
-    d_4_1_Core->VertexAttribL1d(index, x);
+    d_4_1_Core->f.VertexAttribL1d(index, x);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
 {
-    d_4_1_Core->GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
+    d_4_1_Core->f.GetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glValidateProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->ValidateProgramPipeline(pipeline);
+    d_4_1_Core->f.ValidateProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3x2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2x3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2dv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2dv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix4fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix4fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix3fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix3fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniformMatrix2fv(program, location, count, transpose, value);
+    d_4_1_Core->f.ProgramUniformMatrix2fv(program, location, count, transpose, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform4uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
 {
-    d_4_1_Core->ProgramUniform4ui(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4ui(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform4dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
 {
-    d_4_1_Core->ProgramUniform4d(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4d(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform4fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
 {
-    d_4_1_Core->ProgramUniform4f(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4f(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform4iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform4iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
 {
-    d_4_1_Core->ProgramUniform4i(program, location, v0, v1, v2, v3);
+    d_4_1_Core->f.ProgramUniform4i(program, location, v0, v1, v2, v3);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform3uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
 {
-    d_4_1_Core->ProgramUniform3ui(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3ui(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform3dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
 {
-    d_4_1_Core->ProgramUniform3d(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3d(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform3fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
 {
-    d_4_1_Core->ProgramUniform3f(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3f(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform3iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform3iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
 {
-    d_4_1_Core->ProgramUniform3i(program, location, v0, v1, v2);
+    d_4_1_Core->f.ProgramUniform3i(program, location, v0, v1, v2);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform2uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
 {
-    d_4_1_Core->ProgramUniform2ui(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2ui(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform2dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
 {
-    d_4_1_Core->ProgramUniform2d(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2d(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform2fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
 {
-    d_4_1_Core->ProgramUniform2f(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2f(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform2iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform2iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
 {
-    d_4_1_Core->ProgramUniform2i(program, location, v0, v1);
+    d_4_1_Core->f.ProgramUniform2i(program, location, v0, v1);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
 {
-    d_4_1_Core->ProgramUniform1uiv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1uiv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform1ui(GLuint program, GLint location, GLuint v0)
 {
-    d_4_1_Core->ProgramUniform1ui(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1ui(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
 {
-    d_4_1_Core->ProgramUniform1dv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1dv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform1d(GLuint program, GLint location, GLdouble v0)
 {
-    d_4_1_Core->ProgramUniform1d(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1d(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
 {
-    d_4_1_Core->ProgramUniform1fv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1fv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform1f(GLuint program, GLint location, GLfloat v0)
 {
-    d_4_1_Core->ProgramUniform1f(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1f(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
 {
-    d_4_1_Core->ProgramUniform1iv(program, location, count, value);
+    d_4_1_Core->f.ProgramUniform1iv(program, location, count, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramUniform1i(GLuint program, GLint location, GLint v0)
 {
-    d_4_1_Core->ProgramUniform1i(program, location, v0);
+    d_4_1_Core->f.ProgramUniform1i(program, location, v0);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
 {
-    d_4_1_Core->GetProgramPipelineiv(pipeline, pname, params);
+    d_4_1_Core->f.GetProgramPipelineiv(pipeline, pname, params);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Core::glIsProgramPipeline(GLuint pipeline)
 {
-    return d_4_1_Core->IsProgramPipeline(pipeline);
+    return d_4_1_Core->f.IsProgramPipeline(pipeline);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGenProgramPipelines(GLsizei n, GLuint *pipelines)
 {
-    d_4_1_Core->GenProgramPipelines(n, pipelines);
+    d_4_1_Core->f.GenProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
 {
-    d_4_1_Core->DeleteProgramPipelines(n, pipelines);
+    d_4_1_Core->f.DeleteProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindProgramPipeline(GLuint pipeline)
 {
-    d_4_1_Core->BindProgramPipeline(pipeline);
+    d_4_1_Core->f.BindProgramPipeline(pipeline);
 }
 
 inline GLuint QOpenGLFunctions_4_5_Core::glCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
 {
-    return d_4_1_Core->CreateShaderProgramv(type, count, strings);
+    return d_4_1_Core->f.CreateShaderProgramv(type, count, strings);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glActiveShaderProgram(GLuint pipeline, GLuint program)
 {
-    d_4_1_Core->ActiveShaderProgram(pipeline, program);
+    d_4_1_Core->f.ActiveShaderProgram(pipeline, program);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
 {
-    d_4_1_Core->UseProgramStages(pipeline, stages, program);
+    d_4_1_Core->f.UseProgramStages(pipeline, stages, program);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramParameteri(GLuint program, GLenum pname, GLint value)
 {
-    d_4_1_Core->ProgramParameteri(program, pname, value);
+    d_4_1_Core->f.ProgramParameteri(program, pname, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
 {
-    d_4_1_Core->ProgramBinary(program, binaryFormat, binary, length);
+    d_4_1_Core->f.ProgramBinary(program, binaryFormat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)
 {
-    d_4_1_Core->GetProgramBinary(program, bufSize, length, binaryFormat, binary);
+    d_4_1_Core->f.GetProgramBinary(program, bufSize, length, binaryFormat, binary);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearDepthf(GLfloat dd)
 {
-    d_4_1_Core->ClearDepthf(dd);
+    d_4_1_Core->f.ClearDepthf(dd);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDepthRangef(GLfloat n, GLfloat f)
 {
-    d_4_1_Core->DepthRangef(n, f);
+    d_4_1_Core->f.DepthRangef(n, f);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
 {
-    d_4_1_Core->GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
+    d_4_1_Core->f.GetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length)
 {
-    d_4_1_Core->ShaderBinary(count, shaders, binaryformat, binary, length);
+    d_4_1_Core->f.ShaderBinary(count, shaders, binaryformat, binary, length);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glReleaseShaderCompiler()
 {
-    d_4_1_Core->ReleaseShaderCompiler();
+    d_4_1_Core->f.ReleaseShaderCompiler();
 }
 
 
 // OpenGL 4.2 core functions
 inline void QOpenGLFunctions_4_5_Core::glDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
 {
-    d_4_2_Core->DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
+    d_4_2_Core->f.DrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
 {
-    d_4_2_Core->DrawTransformFeedbackInstanced(mode, id, instancecount);
+    d_4_2_Core->f.DrawTransformFeedbackInstanced(mode, id, instancecount);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
-    d_4_2_Core->TexStorage3D(target, levels, internalformat, width, height, depth);
+    d_4_2_Core->f.TexStorage3D(target, levels, internalformat, width, height, depth);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_4_2_Core->TexStorage2D(target, levels, internalformat, width, height);
+    d_4_2_Core->f.TexStorage2D(target, levels, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
 {
-    d_4_2_Core->TexStorage1D(target, levels, internalformat, width);
+    d_4_2_Core->f.TexStorage1D(target, levels, internalformat, width);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glMemoryBarrier(GLbitfield barriers)
 {
-    d_4_2_Core->MemoryBarrier(barriers);
+    d_4_2_Core->f.MemoryBarrier(barriers);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)
 {
-    d_4_2_Core->BindImageTexture(unit, texture, level, layered, layer, access, format);
+    d_4_2_Core->f.BindImageTexture(unit, texture, level, layered, layer, access, format);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
 {
-    d_4_2_Core->GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
+    d_4_2_Core->f.GetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
 {
-    d_4_2_Core->GetInternalformativ(target, internalformat, pname, bufSize, params);
+    d_4_2_Core->f.GetInternalformativ(target, internalformat, pname, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
 {
-    d_4_2_Core->DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
+    d_4_2_Core->f.DrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
 {
-    d_4_2_Core->DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
+    d_4_2_Core->f.DrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
 {
-    d_4_2_Core->DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
+    d_4_2_Core->f.DrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
 }
 
 
 // OpenGL 4.3 core functions
 inline void QOpenGLFunctions_4_5_Core::glGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
 {
-    d_4_3_Core->GetObjectPtrLabel(ptr, bufSize, length, label);
+    d_4_3_Core->f.GetObjectPtrLabel(ptr, bufSize, length, label);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label)
 {
-    d_4_3_Core->ObjectPtrLabel(ptr, length, label);
+    d_4_3_Core->f.ObjectPtrLabel(ptr, length, label);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
 {
-    d_4_3_Core->GetObjectLabel(identifier, name, bufSize, length, label);
+    d_4_3_Core->f.GetObjectLabel(identifier, name, bufSize, length, label);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
 {
-    d_4_3_Core->ObjectLabel(identifier, name, length, label);
+    d_4_3_Core->f.ObjectLabel(identifier, name, length, label);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glPopDebugGroup()
 {
-    d_4_3_Core->PopDebugGroup();
+    d_4_3_Core->f.PopDebugGroup();
 }
 
 inline void QOpenGLFunctions_4_5_Core::glPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message)
 {
-    d_4_3_Core->PushDebugGroup(source, id, length, message);
+    d_4_3_Core->f.PushDebugGroup(source, id, length, message);
 }
 
 inline GLuint QOpenGLFunctions_4_5_Core::glGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
 {
-    return d_4_3_Core->GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
+    return d_4_3_Core->f.GetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
 {
-    d_4_3_Core->DebugMessageCallback(callback, userParam);
+    d_4_3_Core->f.DebugMessageCallback(callback, userParam);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
 {
-    d_4_3_Core->DebugMessageInsert(source, type, id, severity, length, buf);
+    d_4_3_Core->f.DebugMessageInsert(source, type, id, severity, length, buf);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)
 {
-    d_4_3_Core->DebugMessageControl(source, type, severity, count, ids, enabled);
+    d_4_3_Core->f.DebugMessageControl(source, type, severity, count, ids, enabled);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
 {
-    d_4_3_Core->VertexBindingDivisor(bindingindex, divisor);
+    d_4_3_Core->f.VertexBindingDivisor(bindingindex, divisor);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
 {
-    d_4_3_Core->VertexAttribBinding(attribindex, bindingindex);
+    d_4_3_Core->f.VertexAttribBinding(attribindex, bindingindex);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribLFormat(attribindex, size, type, relativeoffset);
+    d_4_3_Core->f.VertexAttribLFormat(attribindex, size, type, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribIFormat(attribindex, size, type, relativeoffset);
+    d_4_3_Core->f.VertexAttribIFormat(attribindex, size, type, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
 {
-    d_4_3_Core->VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
+    d_4_3_Core->f.VertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
 {
-    d_4_3_Core->BindVertexBuffer(bindingindex, buffer, offset, stride);
+    d_4_3_Core->f.BindVertexBuffer(bindingindex, buffer, offset, stride);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
 {
-    d_4_3_Core->TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
+    d_4_3_Core->f.TextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_4_3_Core->TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_4_3_Core->f.TexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_4_3_Core->TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    d_4_3_Core->f.TexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
 {
-    d_4_3_Core->TexBufferRange(target, internalformat, buffer, offset, size);
+    d_4_3_Core->f.TexBufferRange(target, internalformat, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
 {
-    d_4_3_Core->ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
+    d_4_3_Core->f.ShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
 }
 
 inline GLint QOpenGLFunctions_4_5_Core::glGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceLocationIndex(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceLocationIndex(program, programInterface, name);
 }
 
 inline GLint QOpenGLFunctions_4_5_Core::glGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceLocation(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceLocation(program, programInterface, name);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
 {
-    d_4_3_Core->GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
+    d_4_3_Core->f.GetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
 {
-    d_4_3_Core->GetProgramResourceName(program, programInterface, index, bufSize, length, name);
+    d_4_3_Core->f.GetProgramResourceName(program, programInterface, index, bufSize, length, name);
 }
 
 inline GLuint QOpenGLFunctions_4_5_Core::glGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name)
 {
-    return d_4_3_Core->GetProgramResourceIndex(program, programInterface, name);
+    return d_4_3_Core->f.GetProgramResourceIndex(program, programInterface, name);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params)
 {
-    d_4_3_Core->GetProgramInterfaceiv(program, programInterface, pname, params);
+    d_4_3_Core->f.GetProgramInterfaceiv(program, programInterface, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
 {
-    d_4_3_Core->MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
+    d_4_3_Core->f.MultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
 {
-    d_4_3_Core->MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
+    d_4_3_Core->f.MultiDrawArraysIndirect(mode, indirect, drawcount, stride);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_4_3_Core->InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
+    d_4_3_Core->f.InvalidateSubFramebuffer(target, numAttachments, attachments, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
 {
-    d_4_3_Core->InvalidateFramebuffer(target, numAttachments, attachments);
+    d_4_3_Core->f.InvalidateFramebuffer(target, numAttachments, attachments);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glInvalidateBufferData(GLuint buffer)
 {
-    d_4_3_Core->InvalidateBufferData(buffer);
+    d_4_3_Core->f.InvalidateBufferData(buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
 {
-    d_4_3_Core->InvalidateBufferSubData(buffer, offset, length);
+    d_4_3_Core->f.InvalidateBufferSubData(buffer, offset, length);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glInvalidateTexImage(GLuint texture, GLint level)
 {
-    d_4_3_Core->InvalidateTexImage(texture, level);
+    d_4_3_Core->f.InvalidateTexImage(texture, level);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
 {
-    d_4_3_Core->InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
+    d_4_3_Core->f.InvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)
 {
-    d_4_3_Core->GetInternalformati64v(target, internalformat, pname, bufSize, params);
+    d_4_3_Core->f.GetInternalformati64v(target, internalformat, pname, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
 {
-    d_4_3_Core->GetFramebufferParameteriv(target, pname, params);
+    d_4_3_Core->f.GetFramebufferParameteriv(target, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glFramebufferParameteri(GLenum target, GLenum pname, GLint param)
 {
-    d_4_3_Core->FramebufferParameteri(target, pname, param);
+    d_4_3_Core->f.FramebufferParameteri(target, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
 {
-    d_4_3_Core->CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
+    d_4_3_Core->f.CopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDispatchComputeIndirect(GLintptr indirect)
 {
-    d_4_3_Core->DispatchComputeIndirect(indirect);
+    d_4_3_Core->f.DispatchComputeIndirect(indirect);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
 {
-    d_4_3_Core->DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
+    d_4_3_Core->f.DispatchCompute(num_groups_x, num_groups_y, num_groups_z);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
 {
-    d_4_3_Core->ClearBufferSubData(target, internalformat, offset, size, format, type, data);
+    d_4_3_Core->f.ClearBufferSubData(target, internalformat, offset, size, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)
 {
-    d_4_3_Core->ClearBufferData(target, internalformat, format, type, data);
+    d_4_3_Core->f.ClearBufferData(target, internalformat, format, type, data);
 }
 
 
 // OpenGL 4.4 core functions
 inline void QOpenGLFunctions_4_5_Core::glBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
 {
-    d_4_4_Core->BindVertexBuffers(first, count, buffers, offsets, strides);
+    d_4_4_Core->f.BindVertexBuffers(first, count, buffers, offsets, strides);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindImageTextures(GLuint first, GLsizei count, const GLuint *textures)
 {
-    d_4_4_Core->BindImageTextures(first, count, textures);
+    d_4_4_Core->f.BindImageTextures(first, count, textures);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindSamplers(GLuint first, GLsizei count, const GLuint *samplers)
 {
-    d_4_4_Core->BindSamplers(first, count, samplers);
+    d_4_4_Core->f.BindSamplers(first, count, samplers);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindTextures(GLuint first, GLsizei count, const GLuint *textures)
 {
-    d_4_4_Core->BindTextures(first, count, textures);
+    d_4_4_Core->f.BindTextures(first, count, textures);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes)
 {
-    d_4_4_Core->BindBuffersRange(target, first, count, buffers, offsets, sizes);
+    d_4_4_Core->f.BindBuffersRange(target, first, count, buffers, offsets, sizes);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers)
 {
-    d_4_4_Core->BindBuffersBase(target, first, count, buffers);
+    d_4_4_Core->f.BindBuffersBase(target, first, count, buffers);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data)
 {
-    d_4_4_Core->ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
+    d_4_4_Core->f.ClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data)
 {
-    d_4_4_Core->ClearTexImage(texture, level, format, type, data);
+    d_4_4_Core->f.ClearTexImage(texture, level, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)
 {
-    d_4_4_Core->BufferStorage(target, size, data, flags);
+    d_4_4_Core->f.BufferStorage(target, size, data, flags);
 }
 
 
 // OpenGL 4.5 core functions
 inline void QOpenGLFunctions_4_5_Core::glTextureBarrier()
 {
-    d_4_5_Core->TextureBarrier();
+    d_4_5_Core->f.TextureBarrier();
 }
 
 inline void QOpenGLFunctions_4_5_Core::glReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)
 {
-    d_4_5_Core->ReadnPixels(x, y, width, height, format, type, bufSize, data);
+    d_4_5_Core->f.ReadnPixels(x, y, width, height, format, type, bufSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint *params)
 {
-    d_4_5_Core->GetnUniformuiv(program, location, bufSize, params);
+    d_4_5_Core->f.GetnUniformuiv(program, location, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params)
 {
-    d_4_5_Core->GetnUniformiv(program, location, bufSize, params);
+    d_4_5_Core->f.GetnUniformiv(program, location, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
 {
-    d_4_5_Core->GetnUniformfv(program, location, bufSize, params);
+    d_4_5_Core->f.GetnUniformfv(program, location, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetnUniformdv(GLuint program, GLint location, GLsizei bufSize, GLdouble *params)
 {
-    d_4_5_Core->GetnUniformdv(program, location, bufSize, params);
+    d_4_5_Core->f.GetnUniformdv(program, location, bufSize, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetnTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
 {
-    d_4_5_Core->GetnTexImage(target, level, format, type, bufSize, pixels);
+    d_4_5_Core->f.GetnTexImage(target, level, format, type, bufSize, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetnCompressedTexImage(GLenum target, GLint lod, GLsizei bufSize, void *pixels)
 {
-    d_4_5_Core->GetnCompressedTexImage(target, lod, bufSize, pixels);
+    d_4_5_Core->f.GetnCompressedTexImage(target, lod, bufSize, pixels);
 }
 
 inline GLenum QOpenGLFunctions_4_5_Core::glGetGraphicsResetStatus()
 {
-    return d_4_5_Core->GetGraphicsResetStatus();
+    return d_4_5_Core->f.GetGraphicsResetStatus();
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetCompressedTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels)
 {
-    d_4_5_Core->GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
+    d_4_5_Core->f.GetCompressedTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
 {
-    d_4_5_Core->GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
+    d_4_5_Core->f.GetTextureSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glMemoryBarrierByRegion(GLbitfield barriers)
 {
-    d_4_5_Core->MemoryBarrierByRegion(barriers);
+    d_4_5_Core->f.MemoryBarrierByRegion(barriers);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCreateQueries(GLenum target, GLsizei n, GLuint *ids)
 {
-    d_4_5_Core->CreateQueries(target, n, ids);
+    d_4_5_Core->f.CreateQueries(target, n, ids);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCreateProgramPipelines(GLsizei n, GLuint *pipelines)
 {
-    d_4_5_Core->CreateProgramPipelines(n, pipelines);
+    d_4_5_Core->f.CreateProgramPipelines(n, pipelines);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCreateSamplers(GLsizei n, GLuint *samplers)
 {
-    d_4_5_Core->CreateSamplers(n, samplers);
+    d_4_5_Core->f.CreateSamplers(n, samplers);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetVertexArrayIndexed64iv(GLuint vaobj, GLuint index, GLenum pname, GLint64 *param)
 {
-    d_4_5_Core->GetVertexArrayIndexed64iv(vaobj, index, pname, param);
+    d_4_5_Core->f.GetVertexArrayIndexed64iv(vaobj, index, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetVertexArrayIndexediv(GLuint vaobj, GLuint index, GLenum pname, GLint *param)
 {
-    d_4_5_Core->GetVertexArrayIndexediv(vaobj, index, pname, param);
+    d_4_5_Core->f.GetVertexArrayIndexediv(vaobj, index, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetVertexArrayiv(GLuint vaobj, GLenum pname, GLint *param)
 {
-    d_4_5_Core->GetVertexArrayiv(vaobj, pname, param);
+    d_4_5_Core->f.GetVertexArrayiv(vaobj, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexArrayBindingDivisor(GLuint vaobj, GLuint bindingindex, GLuint divisor)
 {
-    d_4_5_Core->VertexArrayBindingDivisor(vaobj, bindingindex, divisor);
+    d_4_5_Core->f.VertexArrayBindingDivisor(vaobj, bindingindex, divisor);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexArrayAttribLFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
 {
-    d_4_5_Core->VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);
+    d_4_5_Core->f.VertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexArrayAttribIFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
 {
-    d_4_5_Core->VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);
+    d_4_5_Core->f.VertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexArrayAttribFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)
 {
-    d_4_5_Core->VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
+    d_4_5_Core->f.VertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexArrayAttribBinding(GLuint vaobj, GLuint attribindex, GLuint bindingindex)
 {
-    d_4_5_Core->VertexArrayAttribBinding(vaobj, attribindex, bindingindex);
+    d_4_5_Core->f.VertexArrayAttribBinding(vaobj, attribindex, bindingindex);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexArrayVertexBuffers(GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
 {
-    d_4_5_Core->VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);
+    d_4_5_Core->f.VertexArrayVertexBuffers(vaobj, first, count, buffers, offsets, strides);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexArrayVertexBuffer(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
 {
-    d_4_5_Core->VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);
+    d_4_5_Core->f.VertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glVertexArrayElementBuffer(GLuint vaobj, GLuint buffer)
 {
-    d_4_5_Core->VertexArrayElementBuffer(vaobj, buffer);
+    d_4_5_Core->f.VertexArrayElementBuffer(vaobj, buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glEnableVertexArrayAttrib(GLuint vaobj, GLuint index)
 {
-    d_4_5_Core->EnableVertexArrayAttrib(vaobj, index);
+    d_4_5_Core->f.EnableVertexArrayAttrib(vaobj, index);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glDisableVertexArrayAttrib(GLuint vaobj, GLuint index)
 {
-    d_4_5_Core->DisableVertexArrayAttrib(vaobj, index);
+    d_4_5_Core->f.DisableVertexArrayAttrib(vaobj, index);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCreateVertexArrays(GLsizei n, GLuint *arrays)
 {
-    d_4_5_Core->CreateVertexArrays(n, arrays);
+    d_4_5_Core->f.CreateVertexArrays(n, arrays);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTextureParameteriv(GLuint texture, GLenum pname, GLint *params)
 {
-    d_4_5_Core->GetTextureParameteriv(texture, pname, params);
+    d_4_5_Core->f.GetTextureParameteriv(texture, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTextureParameterIuiv(GLuint texture, GLenum pname, GLuint *params)
 {
-    d_4_5_Core->GetTextureParameterIuiv(texture, pname, params);
+    d_4_5_Core->f.GetTextureParameterIuiv(texture, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTextureParameterIiv(GLuint texture, GLenum pname, GLint *params)
 {
-    d_4_5_Core->GetTextureParameterIiv(texture, pname, params);
+    d_4_5_Core->f.GetTextureParameterIiv(texture, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTextureParameterfv(GLuint texture, GLenum pname, GLfloat *params)
 {
-    d_4_5_Core->GetTextureParameterfv(texture, pname, params);
+    d_4_5_Core->f.GetTextureParameterfv(texture, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTextureLevelParameteriv(GLuint texture, GLint level, GLenum pname, GLint *params)
 {
-    d_4_5_Core->GetTextureLevelParameteriv(texture, level, pname, params);
+    d_4_5_Core->f.GetTextureLevelParameteriv(texture, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTextureLevelParameterfv(GLuint texture, GLint level, GLenum pname, GLfloat *params)
 {
-    d_4_5_Core->GetTextureLevelParameterfv(texture, level, pname, params);
+    d_4_5_Core->f.GetTextureLevelParameterfv(texture, level, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetCompressedTextureImage(GLuint texture, GLint level, GLsizei bufSize, void *pixels)
 {
-    d_4_5_Core->GetCompressedTextureImage(texture, level, bufSize, pixels);
+    d_4_5_Core->f.GetCompressedTextureImage(texture, level, bufSize, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTextureImage(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
 {
-    d_4_5_Core->GetTextureImage(texture, level, format, type, bufSize, pixels);
+    d_4_5_Core->f.GetTextureImage(texture, level, format, type, bufSize, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBindTextureUnit(GLuint unit, GLuint texture)
 {
-    d_4_5_Core->BindTextureUnit(unit, texture);
+    d_4_5_Core->f.BindTextureUnit(unit, texture);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGenerateTextureMipmap(GLuint texture)
 {
-    d_4_5_Core->GenerateTextureMipmap(texture);
+    d_4_5_Core->f.GenerateTextureMipmap(texture);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureParameteriv(GLuint texture, GLenum pname, const GLint *param)
 {
-    d_4_5_Core->TextureParameteriv(texture, pname, param);
+    d_4_5_Core->f.TextureParameteriv(texture, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureParameterIuiv(GLuint texture, GLenum pname, const GLuint *params)
 {
-    d_4_5_Core->TextureParameterIuiv(texture, pname, params);
+    d_4_5_Core->f.TextureParameterIuiv(texture, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureParameterIiv(GLuint texture, GLenum pname, const GLint *params)
 {
-    d_4_5_Core->TextureParameterIiv(texture, pname, params);
+    d_4_5_Core->f.TextureParameterIiv(texture, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureParameteri(GLuint texture, GLenum pname, GLint param)
 {
-    d_4_5_Core->TextureParameteri(texture, pname, param);
+    d_4_5_Core->f.TextureParameteri(texture, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureParameterfv(GLuint texture, GLenum pname, const GLfloat *param)
 {
-    d_4_5_Core->TextureParameterfv(texture, pname, param);
+    d_4_5_Core->f.TextureParameterfv(texture, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureParameterf(GLuint texture, GLenum pname, GLfloat param)
 {
-    d_4_5_Core->TextureParameterf(texture, pname, param);
+    d_4_5_Core->f.TextureParameterf(texture, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCopyTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_4_5_Core->CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
+    d_4_5_Core->f.CopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCopyTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_4_5_Core->CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
+    d_4_5_Core->f.CopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCopyTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
 {
-    d_4_5_Core->CopyTextureSubImage1D(texture, level, xoffset, x, y, width);
+    d_4_5_Core->f.CopyTextureSubImage1D(texture, level, xoffset, x, y, width);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCompressedTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_4_5_Core->CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
+    d_4_5_Core->f.CompressedTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCompressedTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_4_5_Core->CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
+    d_4_5_Core->f.CompressedTextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCompressedTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
 {
-    d_4_5_Core->CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
+    d_4_5_Core->f.CompressedTextureSubImage1D(texture, level, xoffset, width, format, imageSize, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
 {
-    d_4_5_Core->TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
+    d_4_5_Core->f.TextureSubImage3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
 {
-    d_4_5_Core->TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
+    d_4_5_Core->f.TextureSubImage2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
 {
-    d_4_5_Core->TextureSubImage1D(texture, level, xoffset, width, format, type, pixels);
+    d_4_5_Core->f.TextureSubImage1D(texture, level, xoffset, width, format, type, pixels);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureStorage3DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)
 {
-    d_4_5_Core->TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);
+    d_4_5_Core->f.TextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureStorage2DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)
 {
-    d_4_5_Core->TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);
+    d_4_5_Core->f.TextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureStorage3D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
 {
-    d_4_5_Core->TextureStorage3D(texture, levels, internalformat, width, height, depth);
+    d_4_5_Core->f.TextureStorage3D(texture, levels, internalformat, width, height, depth);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureStorage2D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_4_5_Core->TextureStorage2D(texture, levels, internalformat, width, height);
+    d_4_5_Core->f.TextureStorage2D(texture, levels, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureStorage1D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width)
 {
-    d_4_5_Core->TextureStorage1D(texture, levels, internalformat, width);
+    d_4_5_Core->f.TextureStorage1D(texture, levels, internalformat, width);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureBufferRange(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizei size)
 {
-    d_4_5_Core->TextureBufferRange(texture, internalformat, buffer, offset, size);
+    d_4_5_Core->f.TextureBufferRange(texture, internalformat, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTextureBuffer(GLuint texture, GLenum internalformat, GLuint buffer)
 {
-    d_4_5_Core->TextureBuffer(texture, internalformat, buffer);
+    d_4_5_Core->f.TextureBuffer(texture, internalformat, buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCreateTextures(GLenum target, GLsizei n, GLuint *textures)
 {
-    d_4_5_Core->CreateTextures(target, n, textures);
+    d_4_5_Core->f.CreateTextures(target, n, textures);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetNamedRenderbufferParameteriv(GLuint renderbuffer, GLenum pname, GLint *params)
 {
-    d_4_5_Core->GetNamedRenderbufferParameteriv(renderbuffer, pname, params);
+    d_4_5_Core->f.GetNamedRenderbufferParameteriv(renderbuffer, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glNamedRenderbufferStorageMultisample(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_4_5_Core->NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
+    d_4_5_Core->f.NamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glNamedRenderbufferStorage(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height)
 {
-    d_4_5_Core->NamedRenderbufferStorage(renderbuffer, internalformat, width, height);
+    d_4_5_Core->f.NamedRenderbufferStorage(renderbuffer, internalformat, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCreateRenderbuffers(GLsizei n, GLuint *renderbuffers)
 {
-    d_4_5_Core->CreateRenderbuffers(n, renderbuffers);
+    d_4_5_Core->f.CreateRenderbuffers(n, renderbuffers);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetNamedFramebufferAttachmentParameteriv(GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params)
 {
-    d_4_5_Core->GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
+    d_4_5_Core->f.GetNamedFramebufferAttachmentParameteriv(framebuffer, attachment, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetNamedFramebufferParameteriv(GLuint framebuffer, GLenum pname, GLint *param)
 {
-    d_4_5_Core->GetNamedFramebufferParameteriv(framebuffer, pname, param);
+    d_4_5_Core->f.GetNamedFramebufferParameteriv(framebuffer, pname, param);
 }
 
 inline GLenum QOpenGLFunctions_4_5_Core::glCheckNamedFramebufferStatus(GLuint framebuffer, GLenum target)
 {
-    return d_4_5_Core->CheckNamedFramebufferStatus(framebuffer, target);
+    return d_4_5_Core->f.CheckNamedFramebufferStatus(framebuffer, target);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glBlitNamedFramebuffer(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
 {
-    d_4_5_Core->BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    d_4_5_Core->f.BlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearNamedFramebufferfi(GLuint framebuffer, GLenum buffer, GLfloat depth, GLint stencil)
 {
-    d_4_5_Core->ClearNamedFramebufferfi(framebuffer, buffer, depth, stencil);
+    d_4_5_Core->f.ClearNamedFramebufferfi(framebuffer, buffer, depth, stencil);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearNamedFramebufferfv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value)
 {
-    d_4_5_Core->ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
+    d_4_5_Core->f.ClearNamedFramebufferfv(framebuffer, buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearNamedFramebufferuiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value)
 {
-    d_4_5_Core->ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
+    d_4_5_Core->f.ClearNamedFramebufferuiv(framebuffer, buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearNamedFramebufferiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value)
 {
-    d_4_5_Core->ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
+    d_4_5_Core->f.ClearNamedFramebufferiv(framebuffer, buffer, drawbuffer, value);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glInvalidateNamedFramebufferSubData(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
 {
-    d_4_5_Core->InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);
+    d_4_5_Core->f.InvalidateNamedFramebufferSubData(framebuffer, numAttachments, attachments, x, y, width, height);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glInvalidateNamedFramebufferData(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments)
 {
-    d_4_5_Core->InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments);
+    d_4_5_Core->f.InvalidateNamedFramebufferData(framebuffer, numAttachments, attachments);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glNamedFramebufferReadBuffer(GLuint framebuffer, GLenum src)
 {
-    d_4_5_Core->NamedFramebufferReadBuffer(framebuffer, src);
+    d_4_5_Core->f.NamedFramebufferReadBuffer(framebuffer, src);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glNamedFramebufferDrawBuffers(GLuint framebuffer, GLsizei n, const GLenum *bufs)
 {
-    d_4_5_Core->NamedFramebufferDrawBuffers(framebuffer, n, bufs);
+    d_4_5_Core->f.NamedFramebufferDrawBuffers(framebuffer, n, bufs);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glNamedFramebufferDrawBuffer(GLuint framebuffer, GLenum buf)
 {
-    d_4_5_Core->NamedFramebufferDrawBuffer(framebuffer, buf);
+    d_4_5_Core->f.NamedFramebufferDrawBuffer(framebuffer, buf);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glNamedFramebufferTextureLayer(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer)
 {
-    d_4_5_Core->NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
+    d_4_5_Core->f.NamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glNamedFramebufferTexture(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)
 {
-    d_4_5_Core->NamedFramebufferTexture(framebuffer, attachment, texture, level);
+    d_4_5_Core->f.NamedFramebufferTexture(framebuffer, attachment, texture, level);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glNamedFramebufferParameteri(GLuint framebuffer, GLenum pname, GLint param)
 {
-    d_4_5_Core->NamedFramebufferParameteri(framebuffer, pname, param);
+    d_4_5_Core->f.NamedFramebufferParameteri(framebuffer, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glNamedFramebufferRenderbuffer(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
 {
-    d_4_5_Core->NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);
+    d_4_5_Core->f.NamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCreateFramebuffers(GLsizei n, GLuint *framebuffers)
 {
-    d_4_5_Core->CreateFramebuffers(n, framebuffers);
+    d_4_5_Core->f.CreateFramebuffers(n, framebuffers);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizei size, void *data)
 {
-    d_4_5_Core->GetNamedBufferSubData(buffer, offset, size, data);
+    d_4_5_Core->f.GetNamedBufferSubData(buffer, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetNamedBufferPointerv(GLuint buffer, GLenum pname, void * *params)
 {
-    d_4_5_Core->GetNamedBufferPointerv(buffer, pname, params);
+    d_4_5_Core->f.GetNamedBufferPointerv(buffer, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetNamedBufferParameteri64v(GLuint buffer, GLenum pname, GLint64 *params)
 {
-    d_4_5_Core->GetNamedBufferParameteri64v(buffer, pname, params);
+    d_4_5_Core->f.GetNamedBufferParameteri64v(buffer, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetNamedBufferParameteriv(GLuint buffer, GLenum pname, GLint *params)
 {
-    d_4_5_Core->GetNamedBufferParameteriv(buffer, pname, params);
+    d_4_5_Core->f.GetNamedBufferParameteriv(buffer, pname, params);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glFlushMappedNamedBufferRange(GLuint buffer, GLintptr offset, GLsizei length)
 {
-    d_4_5_Core->FlushMappedNamedBufferRange(buffer, offset, length);
+    d_4_5_Core->f.FlushMappedNamedBufferRange(buffer, offset, length);
 }
 
 inline GLboolean QOpenGLFunctions_4_5_Core::glUnmapNamedBuffer(GLuint buffer)
 {
-    return d_4_5_Core->UnmapNamedBuffer(buffer);
+    return d_4_5_Core->f.UnmapNamedBuffer(buffer);
 }
 
 inline void * QOpenGLFunctions_4_5_Core::glMapNamedBufferRange(GLuint buffer, GLintptr offset, GLsizei length, GLbitfield access)
 {
-    return d_4_5_Core->MapNamedBufferRange(buffer, offset, length, access);
+    return d_4_5_Core->f.MapNamedBufferRange(buffer, offset, length, access);
 }
 
 inline void * QOpenGLFunctions_4_5_Core::glMapNamedBuffer(GLuint buffer, GLenum access)
 {
-    return d_4_5_Core->MapNamedBuffer(buffer, access);
+    return d_4_5_Core->f.MapNamedBuffer(buffer, access);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearNamedBufferSubData(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizei size, GLenum format, GLenum type, const void *data)
 {
-    d_4_5_Core->ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);
+    d_4_5_Core->f.ClearNamedBufferSubData(buffer, internalformat, offset, size, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClearNamedBufferData(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data)
 {
-    d_4_5_Core->ClearNamedBufferData(buffer, internalformat, format, type, data);
+    d_4_5_Core->f.ClearNamedBufferData(buffer, internalformat, format, type, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCopyNamedBufferSubData(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizei size)
 {
-    d_4_5_Core->CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);
+    d_4_5_Core->f.CopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizei size, const void *data)
 {
-    d_4_5_Core->NamedBufferSubData(buffer, offset, size, data);
+    d_4_5_Core->f.NamedBufferSubData(buffer, offset, size, data);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glNamedBufferData(GLuint buffer, GLsizei size, const void *data, GLenum usage)
 {
-    d_4_5_Core->NamedBufferData(buffer, size, data, usage);
+    d_4_5_Core->f.NamedBufferData(buffer, size, data, usage);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glNamedBufferStorage(GLuint buffer, GLsizei size, const void *data, GLbitfield flags)
 {
-    d_4_5_Core->NamedBufferStorage(buffer, size, data, flags);
+    d_4_5_Core->f.NamedBufferStorage(buffer, size, data, flags);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCreateBuffers(GLsizei n, GLuint *buffers)
 {
-    d_4_5_Core->CreateBuffers(n, buffers);
+    d_4_5_Core->f.CreateBuffers(n, buffers);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, GLint64 *param)
 {
-    d_4_5_Core->GetTransformFeedbacki64_v(xfb, pname, index, param);
+    d_4_5_Core->f.GetTransformFeedbacki64_v(xfb, pname, index, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, GLint *param)
 {
-    d_4_5_Core->GetTransformFeedbacki_v(xfb, pname, index, param);
+    d_4_5_Core->f.GetTransformFeedbacki_v(xfb, pname, index, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glGetTransformFeedbackiv(GLuint xfb, GLenum pname, GLint *param)
 {
-    d_4_5_Core->GetTransformFeedbackiv(xfb, pname, param);
+    d_4_5_Core->f.GetTransformFeedbackiv(xfb, pname, param);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTransformFeedbackBufferRange(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizei size)
 {
-    d_4_5_Core->TransformFeedbackBufferRange(xfb, index, buffer, offset, size);
+    d_4_5_Core->f.TransformFeedbackBufferRange(xfb, index, buffer, offset, size);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glTransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer)
 {
-    d_4_5_Core->TransformFeedbackBufferBase(xfb, index, buffer);
+    d_4_5_Core->f.TransformFeedbackBufferBase(xfb, index, buffer);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glCreateTransformFeedbacks(GLsizei n, GLuint *ids)
 {
-    d_4_5_Core->CreateTransformFeedbacks(n, ids);
+    d_4_5_Core->f.CreateTransformFeedbacks(n, ids);
 }
 
 inline void QOpenGLFunctions_4_5_Core::glClipControl(GLenum origin, GLenum depth)
 {
-    d_4_5_Core->ClipControl(origin, depth);
+    d_4_5_Core->f.ClipControl(origin, depth);
 }
 
 
diff --git a/src/gui/opengl/qopenglshaderprogram.cpp b/src/gui/opengl/qopenglshaderprogram.cpp
index 9ac020b64be..4134513210f 100644
--- a/src/gui/opengl/qopenglshaderprogram.cpp
+++ b/src/gui/opengl/qopenglshaderprogram.cpp
@@ -250,7 +250,7 @@ bool QOpenGLShaderPrivate::create()
         shader = glfuncs->glCreateShader(GL_FRAGMENT_SHADER);
     }
     if (!shader) {
-        qWarning() << "QOpenGLShader: could not create shader";
+        qWarning("QOpenGLShader: could not create shader");
         return false;
     }
     shaderGuard = new QOpenGLSharedResourceGuard(context, shader, freeShaderFunc);
@@ -798,7 +798,7 @@ bool QOpenGLShaderProgram::init()
 
     GLuint program = d->glfuncs->glCreateProgram();
     if (!program) {
-        qWarning() << "QOpenGLShaderProgram: could not create shader program";
+        qWarning("QOpenGLShaderProgram: could not create shader program");
         return false;
     }
     if (d->programGuard)
@@ -1050,9 +1050,9 @@ bool QOpenGLShaderProgram::link()
         if (!d->linked) {
             QString name = objectName();
             if (name.isEmpty())
-                qWarning() << "QOpenGLShader::link:" << d->log;
+                qWarning("QOpenGLShader::link: %ls", qUtf16Printable(d->log));
             else
-                qWarning() << "QOpenGLShader::link[" << name << "]:" << d->log;
+                qWarning("QOpenGLShader::link[%ls]: %ls", qUtf16Printable(name), qUtf16Printable(d->log));
         }
         delete [] logbuf;
     }
diff --git a/src/gui/opengl/qopengltexture.cpp b/src/gui/opengl/qopengltexture.cpp
index a0b482e1d2a..1db61b7ca1e 100644
--- a/src/gui/opengl/qopengltexture.cpp
+++ b/src/gui/opengl/qopengltexture.cpp
@@ -81,7 +81,8 @@ QOpenGLTexturePrivate::QOpenGLTexturePrivate(QOpenGLTexture::Target textureTarge
       textureView(false),
       autoGenerateMipMaps(true),
       storageAllocated(false),
-      texFuncs(0)
+      texFuncs(0),
+      functions(0)
 {
     dimensions[0] = dimensions[1] = dimensions[2] = 1;
 
@@ -165,6 +166,7 @@ bool QOpenGLTexturePrivate::create()
         return false;
     }
     context = ctx;
+    functions = ctx->functions();
 
     // Resolve any functions we will need based upon context version and create the texture
     initializeOpenGLFunctions();
@@ -177,7 +179,7 @@ bool QOpenGLTexturePrivate::create()
         feature = static_cast<QOpenGLTexture::Feature>(feature << 1);
     }
 
-    texFuncs->glGenTextures(1, &textureId);
+    functions->glGenTextures(1, &textureId);
     return textureId != 0;
 }
 
@@ -194,9 +196,10 @@ void QOpenGLTexturePrivate::destroy()
         return;
     }
 
-    texFuncs->glDeleteTextures(1, &textureId);
+    functions->glDeleteTextures(1, &textureId);
 
     context = 0;
+    functions = 0;
     textureId = 0;
     format = QOpenGLTexture::NoFormat;
     formatClass = QOpenGLTexture::NoFormatClass;
@@ -231,17 +234,17 @@ void QOpenGLTexturePrivate::destroy()
 
 void QOpenGLTexturePrivate::bind()
 {
-    texFuncs->glBindTexture(target, textureId);
+    functions->glBindTexture(target, textureId);
 }
 
 void QOpenGLTexturePrivate::bind(uint unit, QOpenGLTexture::TextureUnitReset reset)
 {
     GLint oldTextureUnit = 0;
     if (reset == QOpenGLTexture::ResetTextureUnit)
-        texFuncs->glGetIntegerv(GL_ACTIVE_TEXTURE, &oldTextureUnit);
+        functions->glGetIntegerv(GL_ACTIVE_TEXTURE, &oldTextureUnit);
 
     texFuncs->glActiveTexture(GL_TEXTURE0 + unit);
-    texFuncs->glBindTexture(target, textureId);
+    functions->glBindTexture(target, textureId);
 
     if (reset == QOpenGLTexture::ResetTextureUnit)
         texFuncs->glActiveTexture(GL_TEXTURE0 + oldTextureUnit);
@@ -249,17 +252,17 @@ void QOpenGLTexturePrivate::bind(uint unit, QOpenGLTexture::TextureUnitReset res
 
 void QOpenGLTexturePrivate::release()
 {
-    texFuncs->glBindTexture(target, 0);
+    functions->glBindTexture(target, 0);
 }
 
 void QOpenGLTexturePrivate::release(uint unit, QOpenGLTexture::TextureUnitReset reset)
 {
     GLint oldTextureUnit = 0;
     if (reset == QOpenGLTexture::ResetTextureUnit)
-        texFuncs->glGetIntegerv(GL_ACTIVE_TEXTURE, &oldTextureUnit);
+        functions->glGetIntegerv(GL_ACTIVE_TEXTURE, &oldTextureUnit);
 
     texFuncs->glActiveTexture(GL_TEXTURE0 + unit);
-    texFuncs->glBindTexture(target, 0);
+    functions->glBindTexture(target, 0);
 
     if (reset == QOpenGLTexture::ResetTextureUnit)
         texFuncs->glActiveTexture(GL_TEXTURE0 + oldTextureUnit);
@@ -268,18 +271,18 @@ void QOpenGLTexturePrivate::release(uint unit, QOpenGLTexture::TextureUnitReset
 bool QOpenGLTexturePrivate::isBound() const
 {
     GLint boundTextureId = 0;
-    texFuncs->glGetIntegerv(bindingTarget, &boundTextureId);
+    functions->glGetIntegerv(bindingTarget, &boundTextureId);
     return (static_cast<GLuint>(boundTextureId) == textureId);
 }
 
 bool QOpenGLTexturePrivate::isBound(uint unit) const
 {
     GLint oldTextureUnit = 0;
-    texFuncs->glGetIntegerv(GL_ACTIVE_TEXTURE, &oldTextureUnit);
+    functions->glGetIntegerv(GL_ACTIVE_TEXTURE, &oldTextureUnit);
 
     GLint boundTextureId = 0;
     texFuncs->glActiveTexture(GL_TEXTURE0 + unit);
-    texFuncs->glGetIntegerv(bindingTarget, &boundTextureId);
+    functions->glGetIntegerv(bindingTarget, &boundTextureId);
     bool result = (static_cast<GLuint>(boundTextureId) == textureId);
 
     texFuncs->glActiveTexture(GL_TEXTURE0 + oldTextureUnit);
@@ -4107,27 +4110,8 @@ QOpenGLTexture::WrapMode QOpenGLTexture::wrapMode(QOpenGLTexture::CoordinateDire
 */
 void QOpenGLTexture::setBorderColor(QColor color)
 {
-#if !defined(QT_OPENGL_ES_2)
-    if (!QOpenGLContext::currentContext()->isOpenGLES()) {
-        Q_D(QOpenGLTexture);
-        d->create();
-        Q_ASSERT(d->texFuncs);
-        Q_ASSERT(d->textureId);
-        float values[4];
-        values[0] = color.redF();
-        values[1] = color.greenF();
-        values[2] = color.blueF();
-        values[3] = color.alphaF();
-        d->borderColor.clear();
-        for (int i = 0; i < 4; ++i)
-            d->borderColor.append(QVariant(values[i]));
-        d->texFuncs->glTextureParameterfv(d->textureId, d->target, d->bindingTarget, GL_TEXTURE_BORDER_COLOR, values);
-        return;
-    }
-#else
-    Q_UNUSED(color);
-#endif
-    qWarning("QOpenGLTexture: Border color is not supported");
+    setBorderColor(static_cast<float>(color.redF()), static_cast<float>(color.greenF()),
+                   static_cast<float>(color.blueF()), static_cast<float>(color.alphaF()));
 }
 
 /*!
diff --git a/src/gui/opengl/qopengltexture.h b/src/gui/opengl/qopengltexture.h
index e4047afadb0..8c32fcef26c 100644
--- a/src/gui/opengl/qopengltexture.h
+++ b/src/gui/opengl/qopengltexture.h
@@ -55,6 +55,7 @@ class QOpenGLPixelTransferOptions;
 
 class Q_GUI_EXPORT QOpenGLTexture
 {
+    Q_GADGET
 public:
     enum Target {
         Target1D                   = 0x0DE0,    // GL_TEXTURE_1D
@@ -69,6 +70,7 @@ public:
         TargetRectangle            = 0x84F5,    // GL_TEXTURE_RECTANGLE
         TargetBuffer               = 0x8C2A     // GL_TEXTURE_BUFFER
     };
+    Q_ENUM(Target)
 
     enum BindingTarget {
         BindingTarget1D                    = 0x8068,   // GL_TEXTURE_BINDING_1D
@@ -83,16 +85,19 @@ public:
         BindingTargetRectangle             = 0x84F6,   // GL_TEXTURE_BINDING_RECTANGLE
         BindingTargetBuffer                = 0x8C2C    // GL_TEXTURE_BINDING_BUFFER
     };
+    Q_ENUM(BindingTarget)
 
     enum MipMapGeneration {
         GenerateMipMaps,
         DontGenerateMipMaps
     };
+    Q_ENUM(MipMapGeneration)
 
     enum TextureUnitReset {
         ResetTextureUnit,
         DontResetTextureUnit
     };
+    Q_ENUM(TextureUnitReset)
 
     enum TextureFormat {
         NoFormat               = 0,         // GL_NONE
@@ -222,6 +227,7 @@ public:
         LuminanceAlphaFormat   = 0x190A
 
     };
+    Q_ENUM(TextureFormat)
 
     // This is not used externally yet but is reserved to allow checking of
     // compatibility between texture formats
@@ -256,6 +262,7 @@ public:
         CubeMapPositiveZ = 0x8519,  // GL_TEXTURE_CUBE_MAP_POSITIVE_Z
         CubeMapNegativeZ = 0x851A   // GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
     };
+    Q_ENUM(CubeMapFace)
 
     enum PixelFormat {
         NoSourceFormat = 0,         // GL_NONE
@@ -278,6 +285,7 @@ public:
         Luminance      = 0x1909,    // GL_LUMINANCE
         LuminanceAlpha = 0x190A     // GL_LUMINANCE_ALPHA
     };
+    Q_ENUM(PixelFormat)
 
     enum PixelType {
         NoPixelType        = 0,         // GL_NONE
@@ -307,6 +315,7 @@ public:
         UInt32_D24S8       = 0x84FA,    // GL_UNSIGNED_INT_24_8
         Float32_D32_UInt32_S8_X24 = 0x8DAD // GL_FLOAT_32_UNSIGNED_INT_24_8_REV
     };
+    Q_ENUM(PixelType)
 
     enum SwizzleComponent {
         SwizzleRed   = 0x8E42,  // GL_TEXTURE_SWIZZLE_R
@@ -314,6 +323,7 @@ public:
         SwizzleBlue  = 0x8E44,  // GL_TEXTURE_SWIZZLE_B
         SwizzleAlpha = 0x8E45   // GL_TEXTURE_SWIZZLE_A
     };
+    Q_ENUM(SwizzleComponent)
 
     enum SwizzleValue {
         RedValue   = 0x1903, // GL_RED
@@ -323,6 +333,7 @@ public:
         ZeroValue  = 0,      // GL_ZERO
         OneValue   = 1       // GL_ONE
     };
+    Q_ENUM(SwizzleValue)
 
     enum WrapMode {
         Repeat         = 0x2901, // GL_REPEAT
@@ -330,12 +341,14 @@ public:
         ClampToEdge    = 0x812F, // GL_CLAMP_TO_EDGE
         ClampToBorder  = 0x812D  // GL_CLAMP_TO_BORDER
     };
+    Q_ENUM(WrapMode)
 
     enum CoordinateDirection {
         DirectionS = 0x2802, // GL_TEXTURE_WRAP_S
         DirectionT = 0x2803, // GL_TEXTURE_WRAP_T
         DirectionR = 0x8072  // GL_TEXTURE_WRAP_R
     };
+    Q_ENUM(CoordinateDirection)
 
     // Features
     enum Feature {
@@ -360,6 +373,7 @@ public:
 #endif
     };
     Q_DECLARE_FLAGS(Features, Feature)
+    Q_ENUM(Feature)
 
     explicit QOpenGLTexture(Target target);
     explicit QOpenGLTexture(const QImage& image, MipMapGeneration genMipMaps = GenerateMipMaps);
@@ -493,6 +507,7 @@ public:
         DepthMode   = 0x1902,   // GL_DEPTH_COMPONENT
         StencilMode = 0x1901    // GL_STENCIL_INDEX
     };
+    Q_ENUM(DepthStencilMode)
 
     void setDepthStencilMode(DepthStencilMode mode);
     DepthStencilMode depthStencilMode() const;
@@ -507,6 +522,7 @@ public:
         CompareAlways       = 0x0207,   // GL_ALWAYS
         CompareNever        = 0x0200    // GL_NEVER
     };
+    Q_ENUM(ComparisonFunction)
 
     void setComparisonFunction(ComparisonFunction function);
     ComparisonFunction comparisonFunction() const;
@@ -528,6 +544,7 @@ public:
         LinearMipMapNearest     = 0x2701,   // GL_LINEAR_MIPMAP_NEAREST
         LinearMipMapLinear      = 0x2703    // GL_LINEAR_MIPMAP_LINEAR
     };
+    Q_ENUM(Filter)
 
     void setMinificationFilter(Filter filter);
     Filter minificationFilter() const;
diff --git a/src/gui/opengl/qopengltexture_p.h b/src/gui/opengl/qopengltexture_p.h
index 38c5f165363..e9ada026ed4 100644
--- a/src/gui/opengl/qopengltexture_p.h
+++ b/src/gui/opengl/qopengltexture_p.h
@@ -70,6 +70,7 @@ QT_BEGIN_NAMESPACE
 
 class QOpenGLContext;
 class QOpenGLTextureHelper;
+class QOpenGLFunctions;
 
 class QOpenGLTexturePrivate
 {
@@ -163,6 +164,7 @@ public:
     bool storageAllocated;
 
     QOpenGLTextureHelper *texFuncs;
+    QOpenGLFunctions *functions;
 
     QOpenGLTexture::Features features;
 };
diff --git a/src/gui/opengl/qopengltexturehelper.cpp b/src/gui/opengl/qopengltexturehelper.cpp
index a1191834970..be88946e903 100644
--- a/src/gui/opengl/qopengltexturehelper.cpp
+++ b/src/gui/opengl/qopengltexturehelper.cpp
@@ -46,6 +46,7 @@ QT_BEGIN_NAMESPACE
 
 QOpenGLTextureHelper::QOpenGLTextureHelper(QOpenGLContext *context)
 {
+    functions = context->functions();
     // Resolve EXT_direct_state_access entry points if present.
 
     // However, disable it on some systems where DSA is known to be unreliable.
@@ -57,28 +58,28 @@ QOpenGLTextureHelper::QOpenGLTextureHelper(QOpenGLContext *context)
 
     if (allowDSA && !context->isOpenGLES()
         && context->hasExtension(QByteArrayLiteral("GL_EXT_direct_state_access"))) {
-        TextureParameteriEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLint )>(context->getProcAddress(QByteArrayLiteral("glTextureParameteriEXT")));
-        TextureParameterivEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , const GLint *)>(context->getProcAddress(QByteArrayLiteral("glTextureParameterivEXT")));
-        TextureParameterfEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLfloat )>(context->getProcAddress(QByteArrayLiteral("glTextureParameterfEXT")));
-        TextureParameterfvEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , const GLfloat *)>(context->getProcAddress(QByteArrayLiteral("glTextureParameterfvEXT")));
-        GenerateTextureMipmapEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress(QByteArrayLiteral("glGenerateTextureMipmapEXT")));
-        TextureStorage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei )>(context->getProcAddress(QByteArrayLiteral("glTextureStorage3DEXT")));
-        TextureStorage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei , GLsizei )>(context->getProcAddress(QByteArrayLiteral("glTextureStorage2DEXT")));
-        TextureStorage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei )>(context->getProcAddress(QByteArrayLiteral("glTextureStorage1DEXT")));
-        TextureStorage3DMultisampleEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress(QByteArrayLiteral("glTextureStorage3DMultisampleEXT")));
-        TextureStorage2DMultisampleEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLboolean )>(context->getProcAddress(QByteArrayLiteral("glTextureStorage2DMultisampleEXT")));
-        TextureImage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTextureImage3DEXT")));
-        TextureImage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTextureImage2DEXT")));
-        TextureImage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTextureImage1DEXT")));
-        TextureSubImage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTextureSubImage3DEXT")));
-        TextureSubImage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTextureSubImage2DEXT")));
-        TextureSubImage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTextureSubImage1DEXT")));
-        CompressedTextureSubImage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTextureSubImage1DEXT")));
-        CompressedTextureSubImage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTextureSubImage2DEXT")));
-        CompressedTextureSubImage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTextureSubImage3DEXT")));
-        CompressedTextureImage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTextureImage1DEXT")));
-        CompressedTextureImage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTextureImage2DEXT")));
-        CompressedTextureImage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTextureImage3DEXT")));
+        TextureParameteriEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLint )>(context->getProcAddress("glTextureParameteriEXT"));
+        TextureParameterivEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , const GLint *)>(context->getProcAddress("glTextureParameterivEXT"));
+        TextureParameterfEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLfloat )>(context->getProcAddress("glTextureParameterfEXT"));
+        TextureParameterfvEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , const GLfloat *)>(context->getProcAddress("glTextureParameterfvEXT"));
+        GenerateTextureMipmapEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress("glGenerateTextureMipmapEXT"));
+        TextureStorage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei )>(context->getProcAddress("glTextureStorage3DEXT"));
+        TextureStorage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei , GLsizei )>(context->getProcAddress("glTextureStorage2DEXT"));
+        TextureStorage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei )>(context->getProcAddress("glTextureStorage1DEXT"));
+        TextureStorage3DMultisampleEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTextureStorage3DMultisampleEXT"));
+        TextureStorage2DMultisampleEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTextureStorage2DMultisampleEXT"));
+        TextureImage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTextureImage3DEXT"));
+        TextureImage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTextureImage2DEXT"));
+        TextureImage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTextureImage1DEXT"));
+        TextureSubImage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTextureSubImage3DEXT"));
+        TextureSubImage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTextureSubImage2DEXT"));
+        TextureSubImage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTextureSubImage1DEXT"));
+        CompressedTextureSubImage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTextureSubImage1DEXT"));
+        CompressedTextureSubImage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTextureSubImage2DEXT"));
+        CompressedTextureSubImage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTextureSubImage3DEXT"));
+        CompressedTextureImage1DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTextureImage1DEXT"));
+        CompressedTextureImage2DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTextureImage2DEXT"));
+        CompressedTextureImage3DEXT = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTextureImage3DEXT"));
 
         // Use the real DSA functions
         TextureParameteri = &QOpenGLTextureHelper::dsa_TextureParameteri;
@@ -132,8 +133,8 @@ QOpenGLTextureHelper::QOpenGLTextureHelper(QOpenGLContext *context)
     // Some DSA functions are part of NV_texture_multisample instead
     if (!context->isOpenGLES()
         && context->hasExtension(QByteArrayLiteral("GL_NV_texture_multisample"))) {
-        TextureImage3DMultisampleNV = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLint , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress(QByteArrayLiteral("glTextureImage3DMultisampleNV")));
-        TextureImage2DMultisampleNV = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLint , GLsizei , GLsizei , GLboolean )>(context->getProcAddress(QByteArrayLiteral("glTextureImage2DMultisampleNV")));
+        TextureImage3DMultisampleNV = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLint , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTextureImage3DMultisampleNV"));
+        TextureImage2DMultisampleNV = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLint , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTextureImage2DMultisampleNV"));
 
         TextureImage3DMultisample = &QOpenGLTextureHelper::dsa_TextureImage3DMultisample;
         TextureImage2DMultisample = &QOpenGLTextureHelper::dsa_TextureImage2DMultisample;
@@ -142,63 +143,15 @@ QOpenGLTextureHelper::QOpenGLTextureHelper(QOpenGLContext *context)
         TextureImage2DMultisample = &QOpenGLTextureHelper::qt_TextureImage2DMultisample;
     }
 
-    // wglGetProcAddress should not be used to (and indeed will not) load OpenGL <= 1.1 functions.
-    // Hence, we resolve them "the hard way"
-
-#if defined(Q_OS_WIN) && !defined(QT_OPENGL_ES_2)
-    HMODULE handle = static_cast<HMODULE>(QOpenGLContext::openGLModuleHandle());
-    if (!handle)
-        handle = GetModuleHandleA("opengl32.dll");
-
-    // OpenGL 1.0
-    GetIntegerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint *)>(GetProcAddress(handle, QByteArrayLiteral("glGetIntegerv")));
-    GetBooleanv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLboolean *)>(GetProcAddress(handle, QByteArrayLiteral("glGetBooleanv")));
-    PixelStorei = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(GetProcAddress(handle, QByteArrayLiteral("glPixelStorei")));
-    GetTexLevelParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLint *)>(GetProcAddress(handle, QByteArrayLiteral("glGetTexLevelParameteriv")));
-    GetTexLevelParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLfloat *)>(GetProcAddress(handle, QByteArrayLiteral("glGetTexLevelParameterfv")));
-    GetTexParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(GetProcAddress(handle, QByteArrayLiteral("glGetTexParameteriv")));
-    GetTexParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(GetProcAddress(handle, QByteArrayLiteral("glGetTexParameterfv")));
-    GetTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLenum , GLvoid *)>(GetProcAddress(handle, QByteArrayLiteral("glGetTexImage")));
-    TexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(GetProcAddress(handle, QByteArrayLiteral("glTexImage2D")));
-    TexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(GetProcAddress(handle, QByteArrayLiteral("glTexImage1D")));
-    TexParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(GetProcAddress(handle, QByteArrayLiteral("glTexParameteriv")));
-    TexParameteri = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint )>(GetProcAddress(handle, QByteArrayLiteral("glTexParameteri")));
-    TexParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLfloat *)>(GetProcAddress(handle, QByteArrayLiteral("glTexParameterfv")));
-    TexParameterf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat )>(GetProcAddress(handle, QByteArrayLiteral("glTexParameterf")));
-
-    // OpenGL 1.1
-    GenTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(GetProcAddress(handle, QByteArrayLiteral("glGenTextures")));
-    DeleteTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *)>(GetProcAddress(handle, QByteArrayLiteral("glDeleteTextures")));
-    BindTexture = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(GetProcAddress(handle, QByteArrayLiteral("glBindTexture")));
-    TexSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(GetProcAddress(handle, QByteArrayLiteral("glTexSubImage2D")));
-    TexSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *)>(GetProcAddress(handle, QByteArrayLiteral("glTexSubImage1D")));
-
-#elif defined(QT_OPENGL_ES_2)
+#if defined(QT_OPENGL_ES_2)
     // Here we are targeting OpenGL ES 2.0+ only. This is likely using EGL, where,
     // similarly to WGL, non-extension functions (i.e. any function that is part of the
     // GLES spec) *may* not be queried via eglGetProcAddress.
 
     // OpenGL 1.0
-    GetIntegerv = ::glGetIntegerv;
-    GetBooleanv = ::glGetBooleanv;
-    PixelStorei = ::glPixelStorei;
-    GetTexLevelParameteriv = 0;
-    GetTexLevelParameterfv = 0;
-    GetTexParameteriv = ::glGetTexParameteriv;
-    GetTexParameterfv = ::glGetTexParameterfv;
-    GetTexImage = 0;
-    TexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(::glTexImage2D);
     TexImage1D = 0;
-    TexParameteriv = ::glTexParameteriv;
-    TexParameteri = ::glTexParameteri;
-    TexParameterfv = ::glTexParameterfv;
-    TexParameterf = ::glTexParameterf;
 
     // OpenGL 1.1
-    GenTextures = ::glGenTextures;
-    DeleteTextures = ::glDeleteTextures;
-    BindTexture = ::glBindTexture;
-    TexSubImage2D = ::glTexSubImage2D;
     TexSubImage1D = 0;
 
     // OpenGL 1.3
@@ -220,9 +173,9 @@ QOpenGLTextureHelper::QOpenGLTextureHelper(QOpenGLContext *context)
     QOpenGLContext *ctx = QOpenGLContext::currentContext();
     if (ctx->format().majorVersion() >= 3) {
         // OpenGL ES 3.0+ has immutable storage for 2D and 3D at least.
-        QOpenGLES3Helper *es3 = static_cast<QOpenGLExtensions *>(ctx->functions())->gles3Helper();
-        TexStorage3D = es3->TexStorage3D;
-        TexStorage2D = es3->TexStorage2D;
+        QOpenGLExtraFunctionsPrivate *extra = static_cast<QOpenGLExtensions *>(context->extraFunctions())->d();
+        TexStorage3D = extra->f.TexStorage3D;
+        TexStorage2D = extra->f.TexStorage2D;
     } else {
         TexStorage3D = 0;
         TexStorage2D = 0;
@@ -235,83 +188,63 @@ QOpenGLTextureHelper::QOpenGLTextureHelper(QOpenGLContext *context)
     TexBufferRange = 0;
     TextureView = 0;
 
-#else
-
-    // OpenGL 1.0
-    GetIntegerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint *)>(context->getProcAddress(QByteArrayLiteral("glGetIntegerv")));
-    GetBooleanv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLboolean *)>(context->getProcAddress(QByteArrayLiteral("glGetBooleanv")));
-    PixelStorei = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(context->getProcAddress(QByteArrayLiteral("glPixelStorei")));
-    GetTexLevelParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLint *)>(context->getProcAddress(QByteArrayLiteral("glGetTexLevelParameteriv")));
-    GetTexLevelParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLfloat *)>(context->getProcAddress(QByteArrayLiteral("glGetTexLevelParameterfv")));
-    GetTexParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress(QByteArrayLiteral("glGetTexParameteriv")));
-    GetTexParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(context->getProcAddress(QByteArrayLiteral("glGetTexParameterfv")));
-    GetTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLenum , GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glGetTexImage")));
-    TexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTexImage2D")));
-    TexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTexImage1D")));
-    TexParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(context->getProcAddress(QByteArrayLiteral("glTexParameteriv")));
-    TexParameteri = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint )>(context->getProcAddress(QByteArrayLiteral("glTexParameteri")));
-    TexParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLfloat *)>(context->getProcAddress(QByteArrayLiteral("glTexParameterfv")));
-    TexParameterf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat )>(context->getProcAddress(QByteArrayLiteral("glTexParameterf")));
-
-    // OpenGL 1.1
-    GenTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress(QByteArrayLiteral("glGenTextures")));
-    DeleteTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *)>(context->getProcAddress(QByteArrayLiteral("glDeleteTextures")));
-    BindTexture = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress(QByteArrayLiteral("glBindTexture")));
-    TexSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTexSubImage2D")));
-    TexSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTexSubImage1D")));
 #endif
 
     if (context->isOpenGLES() && context->hasExtension(QByteArrayLiteral("GL_OES_texture_3D"))) {
-        TexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*)>(context->getProcAddress(QByteArrayLiteral("glTexImage3DOES")));
-        TexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid*)>(context->getProcAddress(QByteArrayLiteral("glTexSubImage3DOES")));
-        CompressedTexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid*)>(context->getProcAddress(QByteArrayLiteral("glCompressedTexImage3DOES")));
-        CompressedTexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid*)>(context->getProcAddress(QByteArrayLiteral("glCompressedTexSubImage3DOES")));
+        TexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum, GLint, GLint, GLsizei, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*)>(context->getProcAddress("glTexImage3DOES"));
+        TexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, const GLvoid*)>(context->getProcAddress("glTexSubImage3DOES"));
+        CompressedTexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum, GLint, GLenum, GLsizei, GLsizei, GLsizei, GLint, GLsizei, const GLvoid*)>(context->getProcAddress("glCompressedTexImage3DOES"));
+        CompressedTexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid*)>(context->getProcAddress("glCompressedTexSubImage3DOES"));
     } else {
         QOpenGLContext *ctx = QOpenGLContext::currentContext();
         if (ctx->isOpenGLES() && ctx->format().majorVersion() >= 3) {
             // OpenGL ES 3.0+ has glTexImage3D.
-            QOpenGLES3Helper *es3 = static_cast<QOpenGLExtensions *>(ctx->functions())->gles3Helper();
-            TexImage3D = es3->TexImage3D;
-            TexSubImage3D = es3->TexSubImage3D;
-            CompressedTexImage3D = es3->CompressedTexImage3D;
-            CompressedTexSubImage3D = es3->CompressedTexSubImage3D;
+            QOpenGLExtraFunctionsPrivate *extra = static_cast<QOpenGLExtensions *>(context->extraFunctions())->d();
+            TexImage3D = extra->f.TexImage3D;
+            TexSubImage3D = extra->f.TexSubImage3D;
+            CompressedTexImage3D = extra->f.CompressedTexImage3D;
+            CompressedTexSubImage3D = extra->f.CompressedTexSubImage3D;
         } else {
             // OpenGL 1.2
-            TexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTexImage3D")));
-            TexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glTexSubImage3D")));
+            TexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTexImage3D"));
+            TexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTexSubImage3D"));
 
             // OpenGL 1.3
-            CompressedTexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTexImage3D")));
-            CompressedTexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTexSubImage3D")));
+            CompressedTexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexImage3D"));
+            CompressedTexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexSubImage3D"));
         }
     }
 
 #ifndef QT_OPENGL_ES_2
+    // OpenGL 1.0 and 1.1
+    TexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTexImage1D"));
+    TexSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTexSubImage1D"));\
+
     // OpenGL 1.3
-    GetCompressedTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glGetCompressedTexImage")));
-    CompressedTexSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTexSubImage1D")));
-    CompressedTexSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTexSubImage2D")));
-    CompressedTexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTexImage1D")));
-    CompressedTexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress(QByteArrayLiteral("glCompressedTexImage2D")));
-    ActiveTexture = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress(QByteArrayLiteral("glActiveTexture")));
+    GetCompressedTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLvoid *)>(context->getProcAddress("glGetCompressedTexImage"));
+    CompressedTexSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexSubImage1D"));
+    CompressedTexSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexSubImage2D"));
+    CompressedTexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexImage1D"));
+    CompressedTexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexImage2D"));
+    ActiveTexture = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glActiveTexture"));
 
     // OpenGL 3.0
-    GenerateMipmap = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress(QByteArrayLiteral("glGenerateMipmap")));
+    GenerateMipmap = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glGenerateMipmap"));
 
     // OpenGL 3.2
-    TexImage3DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLint , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress(QByteArrayLiteral("glTexImage3DMultisample")));
-    TexImage2DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLint , GLsizei , GLsizei , GLboolean )>(context->getProcAddress(QByteArrayLiteral("glTexImage2DMultisample")));
+    TexImage3DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLint , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexImage3DMultisample"));
+    TexImage2DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLint , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexImage2DMultisample"));
 
     // OpenGL 4.2
-    TexStorage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei )>(context->getProcAddress(QByteArrayLiteral("glTexStorage3D")));
-    TexStorage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei )>(context->getProcAddress(QByteArrayLiteral("glTexStorage2D")));
-    TexStorage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei )>(context->getProcAddress(QByteArrayLiteral("glTexStorage1D")));
+    TexStorage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei )>(context->getProcAddress("glTexStorage3D"));
+    TexStorage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei )>(context->getProcAddress("glTexStorage2D"));
+    TexStorage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei )>(context->getProcAddress("glTexStorage1D"));
 
     // OpenGL 4.3
-    TexStorage3DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress(QByteArrayLiteral("glTexStorage3DMultisample")));
-    TexStorage2DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLboolean )>(context->getProcAddress(QByteArrayLiteral("glTexStorage2DMultisample")));
-    TexBufferRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint , GLintptr , GLsizeiptr )>(context->getProcAddress(QByteArrayLiteral("glTexBufferRange")));
-    TextureView = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLenum , GLuint , GLuint , GLuint , GLuint )>(context->getProcAddress(QByteArrayLiteral("glTextureView")));
+    TexStorage3DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexStorage3DMultisample"));
+    TexStorage2DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexStorage2DMultisample"));
+    TexBufferRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint , GLintptr , GLsizeiptr )>(context->getProcAddress("glTexBufferRange"));
+    TextureView = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLenum , GLuint , GLuint , GLuint , GLuint )>(context->getProcAddress("glTextureView"));
 #endif
 }
 
@@ -464,8 +397,8 @@ namespace {
 class TextureBinder
 {
 public:
-    TextureBinder(QOpenGLTextureHelper *textureFunctions, GLuint texture, GLenum target, GLenum bindingTarget)
-    : m_textureFunctions(textureFunctions)
+    TextureBinder(QOpenGLFunctions *functions, GLuint texture, GLenum target, GLenum bindingTarget)
+    : m_functions(functions)
     {
         // For cubemaps we can't use the standard DSA emulation as it is illegal to
         // try to bind a texture to one of the cubemap face targets. So we force the
@@ -486,17 +419,17 @@ public:
             break;
         }
 
-        m_textureFunctions->glGetIntegerv(bindingTarget, &m_oldTexture);
-        m_textureFunctions->glBindTexture(m_target, texture);
+        m_functions->glGetIntegerv(bindingTarget, &m_oldTexture);
+        m_functions->glBindTexture(m_target, texture);
     }
 
     ~TextureBinder()
     {
-        m_textureFunctions->glBindTexture(m_target, m_oldTexture);
+        m_functions->glBindTexture(m_target, m_oldTexture);
     }
 
 private:
-    QOpenGLTextureHelper *m_textureFunctions;
+    QOpenGLFunctions *m_functions;
     GLenum m_target;
     GLint m_oldTexture;
 };
@@ -505,145 +438,145 @@ private:
 
 void QOpenGLTextureHelper::qt_TextureParameteri(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLint param)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
-    glTexParameteri(target, pname, param);
+    TextureBinder binder(functions, texture, target, bindingTarget);
+    functions->glTexParameteri(target, pname, param);
 }
 
 void QOpenGLTextureHelper::qt_TextureParameteriv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLint *params)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
-    glTexParameteriv(target, pname, params);
+    TextureBinder binder(functions, texture, target, bindingTarget);
+    functions->glTexParameteriv(target, pname, params);
 }
 
 void QOpenGLTextureHelper::qt_TextureParameterf(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, GLfloat param)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
-    glTexParameterf(target, pname, param);
+    TextureBinder binder(functions, texture, target, bindingTarget);
+    functions->glTexParameterf(target, pname, param);
 }
 
 void QOpenGLTextureHelper::qt_TextureParameterfv(GLuint texture, GLenum target, GLenum bindingTarget, GLenum pname, const GLfloat *params)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
-    glTexParameterfv(target, pname, params);
+    TextureBinder binder(functions, texture, target, bindingTarget);
+    functions->glTexParameterfv(target, pname, params);
 }
 
 void QOpenGLTextureHelper::qt_GenerateTextureMipmap(GLuint texture, GLenum target, GLenum bindingTarget)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
-    glGenerateMipmap(target);
+    TextureBinder binder(functions, texture, target, bindingTarget);
+    functions->glGenerateMipmap(target);
 }
 
 void QOpenGLTextureHelper::qt_TextureStorage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glTexStorage3D(target, levels, internalFormat, width, height, depth);
 }
 
 void QOpenGLTextureHelper::qt_TextureStorage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glTexStorage2D(target, levels, internalFormat, width, height);
 }
 
 void QOpenGLTextureHelper::qt_TextureStorage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei levels, GLenum internalFormat, GLsizei width)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glTexStorage1D(target, levels, internalFormat, width);
 }
 
 void QOpenGLTextureHelper::qt_TextureStorage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glTexStorage3DMultisample(target, samples, internalFormat, width, height, depth, fixedSampleLocations);
 }
 
 void QOpenGLTextureHelper::qt_TextureStorage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glTexStorage2DMultisample(target, samples, internalFormat, width, height, fixedSampleLocations);
 }
 
 void QOpenGLTextureHelper::qt_TextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glTexImage3D(target, level, internalFormat, width, height, depth, border, format, type, pixels);
 }
 
 void QOpenGLTextureHelper::qt_TextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
-    glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels);
+    TextureBinder binder(functions, texture, target, bindingTarget);
+    functions->glTexImage2D(target, level, internalFormat, width, height, border, format, type, pixels);
 }
 
 void QOpenGLTextureHelper::qt_TextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glTexImage1D(target, level, internalFormat, width, border, format, type, pixels);
 }
 
 void QOpenGLTextureHelper::qt_TextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
 }
 
 void QOpenGLTextureHelper::qt_TextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
-    glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+    TextureBinder binder(functions, texture, target, bindingTarget);
+    functions->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
 }
 
 void QOpenGLTextureHelper::qt_TextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
 }
 
 void QOpenGLTextureHelper::qt_TextureImage3DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedSampleLocations)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glTexImage3DMultisample(target, samples, internalFormat, width, height, depth, fixedSampleLocations);
 }
 
 void QOpenGLTextureHelper::qt_TextureImage2DMultisample(GLuint texture, GLenum target, GLenum bindingTarget, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glTexImage2DMultisample(target, samples, internalFormat, width, height, fixedSampleLocations);
 }
 
 void QOpenGLTextureHelper::qt_CompressedTextureSubImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *bits)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, bits);
 }
 
 void QOpenGLTextureHelper::qt_CompressedTextureSubImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *bits)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, bits);
 }
 
 void QOpenGLTextureHelper::qt_CompressedTextureSubImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *bits)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
 }
 
 void QOpenGLTextureHelper::qt_CompressedTextureImage1D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *bits)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glCompressedTexImage1D(target, level, internalFormat, width, border, imageSize, bits);
 }
 
 void QOpenGLTextureHelper::qt_CompressedTextureImage2D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *bits)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glCompressedTexImage2D(target, level, internalFormat, width, height, border, imageSize, bits);
 }
 
 void QOpenGLTextureHelper::qt_CompressedTextureImage3D(GLuint texture, GLenum target, GLenum bindingTarget, GLint level, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *bits)
 {
-    TextureBinder binder(this, texture, target, bindingTarget);
+    TextureBinder binder(functions, texture, target, bindingTarget);
     glCompressedTexImage3D(target, level, internalFormat, width, height, depth, border, imageSize, bits);
 }
 
diff --git a/src/gui/opengl/qopengltexturehelper_p.h b/src/gui/opengl/qopengltexturehelper_p.h
index bf655ed9dba..a2556726022 100644
--- a/src/gui/opengl/qopengltexturehelper_p.h
+++ b/src/gui/opengl/qopengltexturehelper_p.h
@@ -58,6 +58,7 @@
 #include "qopengl.h"
 #include "qopenglpixeltransferoptions.h"
 #include "qopengltexture.h"
+#include "qopenglfunctions.h"
 
 QT_BEGIN_NAMESPACE
 
@@ -472,54 +473,8 @@ private:
 
 public:
     // Raw OpenGL functions, resolved and used by our DSA-like static functions if no EXT_direct_state_access is available
+
     // OpenGL 1.0
-    inline void glGetIntegerv(GLenum pname, GLint *params)
-    {
-        GetIntegerv(pname, params);
-    }
-
-    inline void glGetBooleanv(GLenum pname, GLboolean *params)
-    {
-        GetBooleanv(pname, params);
-    }
-
-    inline void glPixelStorei(GLenum pname, GLint param)
-    {
-        PixelStorei(pname, param);
-    }
-
-    inline void glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
-    {
-        GetTexLevelParameteriv(target, level, pname, params);
-    }
-
-    inline void glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
-    {
-        GetTexLevelParameterfv(target, level, pname, params);
-    }
-
-    inline void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
-    {
-        GetTexParameteriv(target, pname, params);
-    }
-
-    inline void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
-    {
-        GetTexParameterfv(target, pname, params);
-    }
-
-    inline void glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
-    {
-        GetTexImage(target, level, format, type, pixels);
-    }
-
-    inline void glTexImage2D(GLenum target, GLint level, GLint internalFormat,
-                             GLsizei width, GLsizei height, GLint border,
-                             GLenum format, GLenum type, const GLvoid *pixels)
-    {
-        TexImage2D(target, level, internalFormat, width, height, border, format, type, pixels);
-    }
-
     inline void glTexImage1D(GLenum target, GLint level, GLint internalFormat,
                              GLsizei width, GLint border,
                              GLenum format, GLenum type, const GLvoid *pixels)
@@ -527,48 +482,7 @@ public:
         TexImage1D(target, level, internalFormat, width, border, format, type, pixels);
     }
 
-    inline void glTexParameteriv(GLenum target, GLenum pname, const GLint *params)
-    {
-        TexParameteriv(target, pname, params);
-    }
-
-    inline void glTexParameteri(GLenum target, GLenum pname, GLint param)
-    {
-        TexParameteri(target, pname, param);
-    }
-
-    inline void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
-    {
-        TexParameterfv(target, pname, params);
-    }
-
-    inline void glTexParameterf(GLenum target, GLenum pname, GLfloat param)
-    {
-        TexParameterf(target, pname, param);
-    }
-
     // OpenGL 1.1
-    inline void glGenTextures(GLsizei n, GLuint *textures)
-    {
-        GenTextures(n, textures);
-    }
-
-    inline void glDeleteTextures(GLsizei n, const GLuint *textures)
-    {
-        DeleteTextures(n, textures);
-    }
-
-    inline void glBindTexture(GLenum target, GLuint texture)
-    {
-        BindTexture(target, texture);
-    }
-
-    inline void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset,
-                                GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
-    {
-        TexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
-    }
-
     inline void glTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width,
                                 GLenum format, GLenum type, const GLvoid *pixels)
     {
@@ -704,23 +618,23 @@ public:
     {
         QOpenGLPixelTransferOptions options;
         int val = 0;
-        glGetIntegerv(GL_UNPACK_ALIGNMENT, &val);
+        functions->glGetIntegerv(GL_UNPACK_ALIGNMENT, &val);
         options.setAlignment(val);
 #if !defined(QT_OPENGL_ES_2)
-        glGetIntegerv(GL_UNPACK_SKIP_IMAGES, &val);
+        functions->glGetIntegerv(GL_UNPACK_SKIP_IMAGES, &val);
         options.setSkipImages(val);
-        glGetIntegerv(GL_UNPACK_SKIP_ROWS, &val);
+        functions->glGetIntegerv(GL_UNPACK_SKIP_ROWS, &val);
         options.setSkipRows(val);
-        glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &val);
+        functions->glGetIntegerv(GL_UNPACK_SKIP_PIXELS, &val);
         options.setSkipPixels(val);
-        glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, &val);
+        functions->glGetIntegerv(GL_UNPACK_IMAGE_HEIGHT, &val);
         options.setImageHeight(val);
-        glGetIntegerv(GL_UNPACK_ROW_LENGTH, &val);
+        functions->glGetIntegerv(GL_UNPACK_ROW_LENGTH, &val);
         options.setRowLength(val);
         GLboolean b = GL_FALSE;
-        glGetBooleanv(GL_UNPACK_LSB_FIRST, &b);
+        functions->glGetBooleanv(GL_UNPACK_LSB_FIRST, &b);
         options.setLeastSignificantByteFirst(b);
-        glGetBooleanv(GL_UNPACK_SWAP_BYTES, &b);
+        functions->glGetBooleanv(GL_UNPACK_SWAP_BYTES, &b);
         options.setSwapBytesEnabled(b);
 #endif
         return options;
@@ -728,18 +642,19 @@ public:
 
     inline void setPixelUploadOptions(const QOpenGLPixelTransferOptions &options)
     {
-        glPixelStorei(GL_UNPACK_ALIGNMENT, options.alignment());
+        functions->glPixelStorei(GL_UNPACK_ALIGNMENT, options.alignment());
 #if !defined(QT_OPENGL_ES_2)
-        glPixelStorei(GL_UNPACK_SKIP_IMAGES, options.skipImages());
-        glPixelStorei(GL_UNPACK_SKIP_ROWS, options.skipRows());
-        glPixelStorei(GL_UNPACK_SKIP_PIXELS, options.skipPixels());
-        glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, options.imageHeight());
-        glPixelStorei(GL_UNPACK_ROW_LENGTH, options.rowLength());
-        glPixelStorei(GL_UNPACK_LSB_FIRST, options.isLeastSignificantBitFirst());
-        glPixelStorei(GL_UNPACK_SWAP_BYTES, options.isSwapBytesEnabled());
+        functions->glPixelStorei(GL_UNPACK_SKIP_IMAGES, options.skipImages());
+        functions->glPixelStorei(GL_UNPACK_SKIP_ROWS, options.skipRows());
+        functions->glPixelStorei(GL_UNPACK_SKIP_PIXELS, options.skipPixels());
+        functions->glPixelStorei(GL_UNPACK_IMAGE_HEIGHT, options.imageHeight());
+        functions->glPixelStorei(GL_UNPACK_ROW_LENGTH, options.rowLength());
+        functions->glPixelStorei(GL_UNPACK_LSB_FIRST, options.isLeastSignificantBitFirst());
+        functions->glPixelStorei(GL_UNPACK_SWAP_BYTES, options.isSwapBytesEnabled());
 #endif
     }
 
+    QOpenGLFunctions *functions;
 private:
     // Typedefs and pointers to member functions used to switch between EXT_direct_state_access and our own emulated DSA.
     // The argument match the corresponding GL function, but there's an extra "GLenum bindingTarget" which gets used with
@@ -827,26 +742,9 @@ private:
     void (QOPENGLF_APIENTRYP TextureImage2DMultisampleNV)(GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean fixedSampleLocations);
 
     // OpenGL 1.0
-    void (QOPENGLF_APIENTRYP GetIntegerv)(GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetBooleanv)(GLenum pname, GLboolean *params);
-    void (QOPENGLF_APIENTRYP PixelStorei)(GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP GetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetTexParameteriv)(GLenum target, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP TexImage2D)(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
     void (QOPENGLF_APIENTRYP TexImage1D)(GLenum target, GLint level, GLint internalFormat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP TexParameteriv)(GLenum target, GLenum pname, const GLint *params);
-    void (QOPENGLF_APIENTRYP TexParameteri)(GLenum target, GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP TexParameterfv)(GLenum target, GLenum pname, const GLfloat *params);
-    void (QOPENGLF_APIENTRYP TexParameterf)(GLenum target, GLenum pname, GLfloat param);
 
     // OpenGL 1.1
-    void (QOPENGLF_APIENTRYP GenTextures)(GLsizei n, GLuint *textures);
-    void (QOPENGLF_APIENTRYP DeleteTextures)(GLsizei n, const GLuint *textures);
-    void (QOPENGLF_APIENTRYP BindTexture)(GLenum target, GLuint texture);
-    void (QOPENGLF_APIENTRYP TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
     void (QOPENGLF_APIENTRYP TexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
 
     // OpenGL 1.2
diff --git a/src/gui/opengl/qopenglversionfunctions.cpp b/src/gui/opengl/qopenglversionfunctions.cpp
index 89f066163ac..9fa224b0aab 100644
--- a/src/gui/opengl/qopenglversionfunctions.cpp
+++ b/src/gui/opengl/qopenglversionfunctions.cpp
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -52,25 +53,73 @@
 
 QT_BEGIN_NAMESPACE
 
-QOpenGLVersionFunctionsBackend *QAbstractOpenGLFunctionsPrivate::functionsBackend(QOpenGLContext *context,
-                                                                                  const QOpenGLVersionStatus &v)
-{
-    Q_ASSERT(context);
-    return context->functionsBackend(v);
+#define QT_OPENGL_COUNT_FUNCTIONS(ret, name, args) +1
+#define QT_OPENGL_FUNCTION_NAMES(ret, name, args) \
+    "gl"#name"\0"
+#define QT_OPENGL_IMPLEMENT(CLASS, FUNCTIONS) \
+void CLASS::init() \
+{ \
+    const char *names = FUNCTIONS(QT_OPENGL_FUNCTION_NAMES); \
+    const char *name = names; \
+    for (int i = 0; i < FUNCTIONS(QT_OPENGL_COUNT_FUNCTIONS); ++i) { \
+        functions[i] = context->getProcAddress(name); \
+        name += strlen(name) + 1; \
+    } \
 }
 
-void QAbstractOpenGLFunctionsPrivate::insertFunctionsBackend(QOpenGLContext *context,
-                                                             const QOpenGLVersionStatus &v,
-                                                             QOpenGLVersionFunctionsBackend *backend)
+QOpenGLVersionFunctionsStorage::QOpenGLVersionFunctionsStorage()
+    : backends(0)
 {
-    Q_ASSERT(context);
-    context->insertFunctionsBackend(v, backend);
 }
 
-void QAbstractOpenGLFunctionsPrivate::removeFunctionsBackend(QOpenGLContext *context, const QOpenGLVersionStatus &v)
+QOpenGLVersionFunctionsStorage::~QOpenGLVersionFunctionsStorage()
+{
+    if (backends) {
+        for (int i = 0; i < QOpenGLVersionFunctionsBackend::OpenGLVersionBackendCount; ++i) {
+            if (backends[i] && !--backends[i]->refs) {
+                // deleting the base class is ok, as the derived classes don't have a destructor
+                delete backends[i];
+            }
+        }
+        delete[] backends;
+    }
+}
+
+QOpenGLVersionFunctionsBackend *QOpenGLVersionFunctionsStorage::backend(QOpenGLContext *context, QOpenGLVersionFunctionsBackend::Version v)
+{
+#ifdef QT_OPENGL_ES
+    Q_UNUSED(context);
+    Q_UNUSED(v);
+    return 0;
+#else
+    if (!backends) {
+        backends = new QOpenGLVersionFunctionsBackend *[QOpenGLVersionFunctionsBackend::OpenGLVersionBackendCount];
+        memset(backends, 0, sizeof(QOpenGLVersionFunctionsBackend *)*QOpenGLVersionFunctionsBackend::OpenGLVersionBackendCount);
+    }
+    if (backends[v])
+        return backends[v];
+
+    switch(v) {
+#define VERSION_ENUM(X) QOpenGLVersionFunctionsBackend::OpenGL_##X
+#define CREATE_BACKEND(X) \
+    case VERSION_ENUM(X): \
+        backends[VERSION_ENUM(X)] = new QOpenGLFunctions_##X##Backend(context); \
+        break;
+    QT_OPENGL_VERSIONS(CREATE_BACKEND)
+    case QOpenGLVersionFunctionsBackend::OpenGLVersionBackendCount:
+        Q_UNREACHABLE();
+    }
+    // the storage keeps one ref
+    ++backends[v]->refs;
+    return backends[v];
+#endif
+}
+
+QOpenGLVersionFunctionsBackend *QAbstractOpenGLFunctionsPrivate::functionsBackend(QOpenGLContext *context, QOpenGLVersionFunctionsBackend::Version v)
 {
     Q_ASSERT(context);
-    context->removeFunctionsBackend(v);
+    QOpenGLVersionFunctionsStorage *storage = context->functionsBackendStorage();
+    return storage->backend(context, v);
 }
 
 void QAbstractOpenGLFunctionsPrivate::insertExternalFunctions(QOpenGLContext *context, QAbstractOpenGLFunctions *f)
@@ -258,1853 +307,36 @@ QOpenGLContext *QAbstractOpenGLFunctions::owningContext() const
 
 #if !defined(QT_OPENGL_ES_2)
 
-QOpenGLFunctions_1_0_CoreBackend::QOpenGLFunctions_1_0_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 1.0 core functions
-#if defined(Q_OS_WIN)
-    HMODULE handle = static_cast<HMODULE>(QOpenGLContext::openGLModuleHandle());
-    if (!handle)
-        handle = GetModuleHandleA("opengl32.dll");
-    Viewport = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLsizei , GLsizei )>(GetProcAddress(handle, "glViewport"));
-    DepthRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble )>(GetProcAddress(handle, "glDepthRange"));
-    IsEnabled = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glIsEnabled"));
-    GetTexLevelParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLint *)>(GetProcAddress(handle, "glGetTexLevelParameteriv"));
-    GetTexLevelParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLfloat *)>(GetProcAddress(handle, "glGetTexLevelParameterfv"));
-    GetTexParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(GetProcAddress(handle, "glGetTexParameteriv"));
-    GetTexParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(GetProcAddress(handle, "glGetTexParameterfv"));
-    GetTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLenum , GLvoid *)>(GetProcAddress(handle, "glGetTexImage"));
-    GetString = reinterpret_cast<const GLubyte * (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glGetString"));
-    GetIntegerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint *)>(GetProcAddress(handle, "glGetIntegerv"));
-    GetFloatv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat *)>(GetProcAddress(handle, "glGetFloatv"));
-    GetError = reinterpret_cast<GLenum (QOPENGLF_APIENTRYP)()>(GetProcAddress(handle, "glGetError"));
-    GetDoublev = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLdouble *)>(GetProcAddress(handle, "glGetDoublev"));
-    GetBooleanv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLboolean *)>(GetProcAddress(handle, "glGetBooleanv"));
-    ReadPixels = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , GLvoid *)>(GetProcAddress(handle, "glReadPixels"));
-    ReadBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glReadBuffer"));
-    PixelStorei = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(GetProcAddress(handle, "glPixelStorei"));
-    PixelStoref = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat )>(GetProcAddress(handle, "glPixelStoref"));
-    DepthFunc = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glDepthFunc"));
-    StencilOp = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum )>(GetProcAddress(handle, "glStencilOp"));
-    StencilFunc = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLuint )>(GetProcAddress(handle, "glStencilFunc"));
-    LogicOp = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glLogicOp"));
-    BlendFunc = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum )>(GetProcAddress(handle, "glBlendFunc"));
-    Flush = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(GetProcAddress(handle, "glFlush"));
-    Finish = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(GetProcAddress(handle, "glFinish"));
-    Enable = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glEnable"));
-    Disable = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glDisable"));
-    DepthMask = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLboolean )>(GetProcAddress(handle, "glDepthMask"));
-    ColorMask = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLboolean , GLboolean , GLboolean , GLboolean )>(GetProcAddress(handle, "glColorMask"));
-    StencilMask = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(GetProcAddress(handle, "glStencilMask"));
-    ClearDepth = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble )>(GetProcAddress(handle, "glClearDepth"));
-    ClearStencil = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint )>(GetProcAddress(handle, "glClearStencil"));
-    ClearColor = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(GetProcAddress(handle, "glClearColor"));
-    Clear = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbitfield )>(GetProcAddress(handle, "glClear"));
-    DrawBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glDrawBuffer"));
-    TexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(GetProcAddress(handle, "glTexImage2D"));
-    TexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(GetProcAddress(handle, "glTexImage1D"));
-    TexParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(GetProcAddress(handle, "glTexParameteriv"));
-    TexParameteri = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint )>(GetProcAddress(handle, "glTexParameteri"));
-    TexParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLfloat *)>(GetProcAddress(handle, "glTexParameterfv"));
-    TexParameterf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat )>(GetProcAddress(handle, "glTexParameterf"));
-    Scissor = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLsizei , GLsizei )>(GetProcAddress(handle, "glScissor"));
-    PolygonMode = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum )>(GetProcAddress(handle, "glPolygonMode"));
-    PointSize = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(GetProcAddress(handle, "glPointSize"));
-    LineWidth = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(GetProcAddress(handle, "glLineWidth"));
-    Hint = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum )>(GetProcAddress(handle, "glHint"));
-    FrontFace = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glFrontFace"));
-    CullFace = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glCullFace"));
-#else
-    Viewport = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLsizei , GLsizei )>(context->getProcAddress("glViewport"));
-    DepthRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble )>(context->getProcAddress("glDepthRange"));
-    IsEnabled = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glIsEnabled"));
-    GetTexLevelParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLint *)>(context->getProcAddress("glGetTexLevelParameteriv"));
-    GetTexLevelParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLfloat *)>(context->getProcAddress("glGetTexLevelParameterfv"));
-    GetTexParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress("glGetTexParameteriv"));
-    GetTexParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(context->getProcAddress("glGetTexParameterfv"));
-    GetTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLenum , GLvoid *)>(context->getProcAddress("glGetTexImage"));
-    GetString = reinterpret_cast<const GLubyte * (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glGetString"));
-    GetIntegerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint *)>(context->getProcAddress("glGetIntegerv"));
-    GetFloatv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat *)>(context->getProcAddress("glGetFloatv"));
-    GetError = reinterpret_cast<GLenum (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glGetError"));
-    GetDoublev = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLdouble *)>(context->getProcAddress("glGetDoublev"));
-    GetBooleanv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLboolean *)>(context->getProcAddress("glGetBooleanv"));
-    ReadPixels = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , GLvoid *)>(context->getProcAddress("glReadPixels"));
-    ReadBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glReadBuffer"));
-    PixelStorei = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(context->getProcAddress("glPixelStorei"));
-    PixelStoref = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat )>(context->getProcAddress("glPixelStoref"));
-    DepthFunc = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glDepthFunc"));
-    StencilOp = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum )>(context->getProcAddress("glStencilOp"));
-    StencilFunc = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLuint )>(context->getProcAddress("glStencilFunc"));
-    LogicOp = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glLogicOp"));
-    BlendFunc = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum )>(context->getProcAddress("glBlendFunc"));
-    Flush = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glFlush"));
-    Finish = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glFinish"));
-    Enable = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glEnable"));
-    Disable = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glDisable"));
-    DepthMask = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLboolean )>(context->getProcAddress("glDepthMask"));
-    ColorMask = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLboolean , GLboolean , GLboolean , GLboolean )>(context->getProcAddress("glColorMask"));
-    StencilMask = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glStencilMask"));
-    ClearDepth = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble )>(context->getProcAddress("glClearDepth"));
-    ClearStencil = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint )>(context->getProcAddress("glClearStencil"));
-    ClearColor = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glClearColor"));
-    Clear = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbitfield )>(context->getProcAddress("glClear"));
-    DrawBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glDrawBuffer"));
-    TexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTexImage2D"));
-    TexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTexImage1D"));
-    TexParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(context->getProcAddress("glTexParameteriv"));
-    TexParameteri = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint )>(context->getProcAddress("glTexParameteri"));
-    TexParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLfloat *)>(context->getProcAddress("glTexParameterfv"));
-    TexParameterf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat )>(context->getProcAddress("glTexParameterf"));
-    Scissor = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLsizei , GLsizei )>(context->getProcAddress("glScissor"));
-    PolygonMode = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum )>(context->getProcAddress("glPolygonMode"));
-    PointSize = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(context->getProcAddress("glPointSize"));
-    LineWidth = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(context->getProcAddress("glLineWidth"));
-    Hint = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum )>(context->getProcAddress("glHint"));
-    FrontFace = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glFrontFace"));
-    CullFace = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glCullFace"));
-#endif
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_1_0_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(1, 0, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_1_1_CoreBackend::QOpenGLFunctions_1_1_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 1.1 core functions
-#if defined(Q_OS_WIN)
-    HMODULE handle = static_cast<HMODULE>(QOpenGLContext::openGLModuleHandle());
-    if (!handle)
-        handle = GetModuleHandleA("opengl32.dll");
-    Indexubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLubyte *)>(GetProcAddress(handle, "glIndexubv"));
-    Indexub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLubyte )>(GetProcAddress(handle, "glIndexub"));
-    IsTexture = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(GetProcAddress(handle, "glIsTexture"));
-    GenTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(GetProcAddress(handle, "glGenTextures"));
-    DeleteTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *)>(GetProcAddress(handle, "glDeleteTextures"));
-    BindTexture = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(GetProcAddress(handle, "glBindTexture"));
-    TexSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(GetProcAddress(handle, "glTexSubImage2D"));
-    TexSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *)>(GetProcAddress(handle, "glTexSubImage1D"));
-    CopyTexSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei )>(GetProcAddress(handle, "glCopyTexSubImage2D"));
-    CopyTexSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint , GLsizei )>(GetProcAddress(handle, "glCopyTexSubImage1D"));
-    CopyTexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint )>(GetProcAddress(handle, "glCopyTexImage2D"));
-    CopyTexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLint )>(GetProcAddress(handle, "glCopyTexImage1D"));
-    PolygonOffset = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(GetProcAddress(handle, "glPolygonOffset"));
-    GetPointerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLvoid * *)>(GetProcAddress(handle, "glGetPointerv"));
-    DrawElements = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , const GLvoid *)>(GetProcAddress(handle, "glDrawElements"));
-    DrawArrays = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLsizei )>(GetProcAddress(handle, "glDrawArrays"));
-#else
-    Indexubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLubyte *)>(context->getProcAddress("glIndexubv"));
-    Indexub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLubyte )>(context->getProcAddress("glIndexub"));
-    IsTexture = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glIsTexture"));
-    GenTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glGenTextures"));
-    DeleteTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *)>(context->getProcAddress("glDeleteTextures"));
-    BindTexture = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glBindTexture"));
-    TexSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTexSubImage2D"));
-    TexSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTexSubImage1D"));
-    CopyTexSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei )>(context->getProcAddress("glCopyTexSubImage2D"));
-    CopyTexSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint , GLsizei )>(context->getProcAddress("glCopyTexSubImage1D"));
-    CopyTexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint )>(context->getProcAddress("glCopyTexImage2D"));
-    CopyTexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLint )>(context->getProcAddress("glCopyTexImage1D"));
-    PolygonOffset = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(context->getProcAddress("glPolygonOffset"));
-    GetPointerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLvoid * *)>(context->getProcAddress("glGetPointerv"));
-    DrawElements = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , const GLvoid *)>(context->getProcAddress("glDrawElements"));
-    DrawArrays = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLsizei )>(context->getProcAddress("glDrawArrays"));
-#endif
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_1_1_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(1, 1, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_1_2_CoreBackend::QOpenGLFunctions_1_2_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 1.2 core functions
-    CopyTexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei )>(context->getProcAddress("glCopyTexSubImage3D"));
-    TexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTexSubImage3D"));
-    TexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glTexImage3D"));
-    DrawRangeElements = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLuint , GLsizei , GLenum , const GLvoid *)>(context->getProcAddress("glDrawRangeElements"));
-    BlendEquation = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glBlendEquation"));
-    BlendColor = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glBlendColor"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_1_2_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(1, 2, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_1_3_CoreBackend::QOpenGLFunctions_1_3_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 1.3 core functions
-    GetCompressedTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLvoid *)>(context->getProcAddress("glGetCompressedTexImage"));
-    CompressedTexSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexSubImage1D"));
-    CompressedTexSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexSubImage2D"));
-    CompressedTexSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexSubImage3D"));
-    CompressedTexImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexImage1D"));
-    CompressedTexImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexImage2D"));
-    CompressedTexImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLsizei , GLsizei , GLsizei , GLint , GLsizei , const GLvoid *)>(context->getProcAddress("glCompressedTexImage3D"));
-    SampleCoverage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLboolean )>(context->getProcAddress("glSampleCoverage"));
-    ActiveTexture = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glActiveTexture"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_1_3_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(1, 3, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_1_4_CoreBackend::QOpenGLFunctions_1_4_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 1.4 core functions
-    PointParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLint *)>(context->getProcAddress("glPointParameteriv"));
-    PointParameteri = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(context->getProcAddress("glPointParameteri"));
-    PointParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLfloat *)>(context->getProcAddress("glPointParameterfv"));
-    PointParameterf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat )>(context->getProcAddress("glPointParameterf"));
-    MultiDrawElements = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLsizei *, GLenum , const GLvoid* const *, GLsizei )>(context->getProcAddress("glMultiDrawElements"));
-    MultiDrawArrays = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLint *, const GLsizei *, GLsizei )>(context->getProcAddress("glMultiDrawArrays"));
-    BlendFuncSeparate = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLenum )>(context->getProcAddress("glBlendFuncSeparate"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_1_4_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(1, 4, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_1_5_CoreBackend::QOpenGLFunctions_1_5_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 1.5 core functions
-    GetBufferPointerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLvoid* *)>(context->getProcAddress("glGetBufferPointerv"));
-    GetBufferParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress("glGetBufferParameteriv"));
-    UnmapBuffer = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glUnmapBuffer"));
-    MapBuffer = reinterpret_cast<GLvoid* (QOPENGLF_APIENTRYP)(GLenum , GLenum )>(context->getProcAddress("glMapBuffer"));
-    GetBufferSubData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLintptr , GLsizeiptr , GLvoid *)>(context->getProcAddress("glGetBufferSubData"));
-    BufferSubData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLintptr , GLsizeiptr , const GLvoid *)>(context->getProcAddress("glBufferSubData"));
-    BufferData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizeiptr , const GLvoid *, GLenum )>(context->getProcAddress("glBufferData"));
-    IsBuffer = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glIsBuffer"));
-    GenBuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glGenBuffers"));
-    DeleteBuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *)>(context->getProcAddress("glDeleteBuffers"));
-    BindBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glBindBuffer"));
-    GetQueryObjectuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint *)>(context->getProcAddress("glGetQueryObjectuiv"));
-    GetQueryObjectiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetQueryObjectiv"));
-    GetQueryiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress("glGetQueryiv"));
-    EndQuery = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glEndQuery"));
-    BeginQuery = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glBeginQuery"));
-    IsQuery = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glIsQuery"));
-    DeleteQueries = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *)>(context->getProcAddress("glDeleteQueries"));
-    GenQueries = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glGenQueries"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_1_5_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(1, 5, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_2_0_CoreBackend::QOpenGLFunctions_2_0_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 2.0 core functions
-    VertexAttribPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLenum , GLboolean , GLsizei , const GLvoid *)>(context->getProcAddress("glVertexAttribPointer"));
-    VertexAttrib4usv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLushort *)>(context->getProcAddress("glVertexAttrib4usv"));
-    VertexAttrib4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttrib4uiv"));
-    VertexAttrib4ubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLubyte *)>(context->getProcAddress("glVertexAttrib4ubv"));
-    VertexAttrib4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib4sv"));
-    VertexAttrib4s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLshort , GLshort , GLshort , GLshort )>(context->getProcAddress("glVertexAttrib4s"));
-    VertexAttrib4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttrib4iv"));
-    VertexAttrib4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glVertexAttrib4fv"));
-    VertexAttrib4f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glVertexAttrib4f"));
-    VertexAttrib4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttrib4dv"));
-    VertexAttrib4d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glVertexAttrib4d"));
-    VertexAttrib4bv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLbyte *)>(context->getProcAddress("glVertexAttrib4bv"));
-    VertexAttrib4Nusv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLushort *)>(context->getProcAddress("glVertexAttrib4Nusv"));
-    VertexAttrib4Nuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttrib4Nuiv"));
-    VertexAttrib4Nubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLubyte *)>(context->getProcAddress("glVertexAttrib4Nubv"));
-    VertexAttrib4Nub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLubyte , GLubyte , GLubyte , GLubyte )>(context->getProcAddress("glVertexAttrib4Nub"));
-    VertexAttrib4Nsv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib4Nsv"));
-    VertexAttrib4Niv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttrib4Niv"));
-    VertexAttrib4Nbv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLbyte *)>(context->getProcAddress("glVertexAttrib4Nbv"));
-    VertexAttrib3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib3sv"));
-    VertexAttrib3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLshort , GLshort , GLshort )>(context->getProcAddress("glVertexAttrib3s"));
-    VertexAttrib3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glVertexAttrib3fv"));
-    VertexAttrib3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glVertexAttrib3f"));
-    VertexAttrib3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttrib3dv"));
-    VertexAttrib3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glVertexAttrib3d"));
-    VertexAttrib2sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib2sv"));
-    VertexAttrib2s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLshort , GLshort )>(context->getProcAddress("glVertexAttrib2s"));
-    VertexAttrib2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glVertexAttrib2fv"));
-    VertexAttrib2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat , GLfloat )>(context->getProcAddress("glVertexAttrib2f"));
-    VertexAttrib2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttrib2dv"));
-    VertexAttrib2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble , GLdouble )>(context->getProcAddress("glVertexAttrib2d"));
-    VertexAttrib1sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib1sv"));
-    VertexAttrib1s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLshort )>(context->getProcAddress("glVertexAttrib1s"));
-    VertexAttrib1fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glVertexAttrib1fv"));
-    VertexAttrib1f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat )>(context->getProcAddress("glVertexAttrib1f"));
-    VertexAttrib1dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttrib1dv"));
-    VertexAttrib1d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble )>(context->getProcAddress("glVertexAttrib1d"));
-    ValidateProgram = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glValidateProgram"));
-    UniformMatrix4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glUniformMatrix4fv"));
-    UniformMatrix3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glUniformMatrix3fv"));
-    UniformMatrix2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glUniformMatrix2fv"));
-    Uniform4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , const GLint *)>(context->getProcAddress("glUniform4iv"));
-    Uniform3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , const GLint *)>(context->getProcAddress("glUniform3iv"));
-    Uniform2iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , const GLint *)>(context->getProcAddress("glUniform2iv"));
-    Uniform1iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , const GLint *)>(context->getProcAddress("glUniform1iv"));
-    Uniform4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , const GLfloat *)>(context->getProcAddress("glUniform4fv"));
-    Uniform3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , const GLfloat *)>(context->getProcAddress("glUniform3fv"));
-    Uniform2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , const GLfloat *)>(context->getProcAddress("glUniform2fv"));
-    Uniform1fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , const GLfloat *)>(context->getProcAddress("glUniform1fv"));
-    Uniform4i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint , GLint , GLint )>(context->getProcAddress("glUniform4i"));
-    Uniform3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint , GLint )>(context->getProcAddress("glUniform3i"));
-    Uniform2i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint )>(context->getProcAddress("glUniform2i"));
-    Uniform1i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint )>(context->getProcAddress("glUniform1i"));
-    Uniform4f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glUniform4f"));
-    Uniform3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glUniform3f"));
-    Uniform2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLfloat , GLfloat )>(context->getProcAddress("glUniform2f"));
-    Uniform1f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLfloat )>(context->getProcAddress("glUniform1f"));
-    UseProgram = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glUseProgram"));
-    ShaderSource = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLchar* const *, const GLint *)>(context->getProcAddress("glShaderSource"));
-    LinkProgram = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glLinkProgram"));
-    IsShader = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glIsShader"));
-    IsProgram = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glIsProgram"));
-    GetVertexAttribPointerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLvoid* *)>(context->getProcAddress("glGetVertexAttribPointerv"));
-    GetVertexAttribiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetVertexAttribiv"));
-    GetVertexAttribfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLfloat *)>(context->getProcAddress("glGetVertexAttribfv"));
-    GetVertexAttribdv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLdouble *)>(context->getProcAddress("glGetVertexAttribdv"));
-    GetUniformiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint *)>(context->getProcAddress("glGetUniformiv"));
-    GetUniformfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLfloat *)>(context->getProcAddress("glGetUniformfv"));
-    GetUniformLocation = reinterpret_cast<GLint (QOPENGLF_APIENTRYP)(GLuint , const GLchar *)>(context->getProcAddress("glGetUniformLocation"));
-    GetShaderSource = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLsizei *, GLchar *)>(context->getProcAddress("glGetShaderSource"));
-    GetShaderInfoLog = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLsizei *, GLchar *)>(context->getProcAddress("glGetShaderInfoLog"));
-    GetShaderiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetShaderiv"));
-    GetProgramInfoLog = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLsizei *, GLchar *)>(context->getProcAddress("glGetProgramInfoLog"));
-    GetProgramiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetProgramiv"));
-    GetAttribLocation = reinterpret_cast<GLint (QOPENGLF_APIENTRYP)(GLuint , const GLchar *)>(context->getProcAddress("glGetAttribLocation"));
-    GetAttachedShaders = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLsizei *, GLuint *)>(context->getProcAddress("glGetAttachedShaders"));
-    GetActiveUniform = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLsizei , GLsizei *, GLint *, GLenum *, GLchar *)>(context->getProcAddress("glGetActiveUniform"));
-    GetActiveAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLsizei , GLsizei *, GLint *, GLenum *, GLchar *)>(context->getProcAddress("glGetActiveAttrib"));
-    EnableVertexAttribArray = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glEnableVertexAttribArray"));
-    DisableVertexAttribArray = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glDisableVertexAttribArray"));
-    DetachShader = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glDetachShader"));
-    DeleteShader = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glDeleteShader"));
-    DeleteProgram = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glDeleteProgram"));
-    CreateShader = reinterpret_cast<GLuint (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glCreateShader"));
-    CreateProgram = reinterpret_cast<GLuint (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glCreateProgram"));
-    CompileShader = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glCompileShader"));
-    BindAttribLocation = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , const GLchar *)>(context->getProcAddress("glBindAttribLocation"));
-    AttachShader = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glAttachShader"));
-    StencilMaskSeparate = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glStencilMaskSeparate"));
-    StencilFuncSeparate = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint , GLuint )>(context->getProcAddress("glStencilFuncSeparate"));
-    StencilOpSeparate = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLenum )>(context->getProcAddress("glStencilOpSeparate"));
-    DrawBuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLenum *)>(context->getProcAddress("glDrawBuffers"));
-    BlendEquationSeparate = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum )>(context->getProcAddress("glBlendEquationSeparate"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_2_0_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(2, 0, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_2_1_CoreBackend::QOpenGLFunctions_2_1_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 2.1 core functions
-    UniformMatrix4x3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glUniformMatrix4x3fv"));
-    UniformMatrix3x4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glUniformMatrix3x4fv"));
-    UniformMatrix4x2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glUniformMatrix4x2fv"));
-    UniformMatrix2x4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glUniformMatrix2x4fv"));
-    UniformMatrix3x2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glUniformMatrix3x2fv"));
-    UniformMatrix2x3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glUniformMatrix2x3fv"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_2_1_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(2, 1, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_3_0_CoreBackend::QOpenGLFunctions_3_0_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 3.0 core functions
-    IsVertexArray = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glIsVertexArray"));
-    GenVertexArrays = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glGenVertexArrays"));
-    DeleteVertexArrays = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *)>(context->getProcAddress("glDeleteVertexArrays"));
-    BindVertexArray = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glBindVertexArray"));
-    FlushMappedBufferRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLintptr , GLsizeiptr )>(context->getProcAddress("glFlushMappedBufferRange"));
-    MapBufferRange = reinterpret_cast<GLvoid* (QOPENGLF_APIENTRYP)(GLenum , GLintptr , GLsizeiptr , GLbitfield )>(context->getProcAddress("glMapBufferRange"));
-    FramebufferTextureLayer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint , GLint , GLint )>(context->getProcAddress("glFramebufferTextureLayer"));
-    RenderbufferStorageMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei )>(context->getProcAddress("glRenderbufferStorageMultisample"));
-    BlitFramebuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint , GLint , GLint , GLint , GLint , GLint , GLbitfield , GLenum )>(context->getProcAddress("glBlitFramebuffer"));
-    GenerateMipmap = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glGenerateMipmap"));
-    GetFramebufferAttachmentParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLint *)>(context->getProcAddress("glGetFramebufferAttachmentParameteriv"));
-    FramebufferRenderbuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLuint )>(context->getProcAddress("glFramebufferRenderbuffer"));
-    FramebufferTexture3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLuint , GLint , GLint )>(context->getProcAddress("glFramebufferTexture3D"));
-    FramebufferTexture2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLuint , GLint )>(context->getProcAddress("glFramebufferTexture2D"));
-    FramebufferTexture1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLuint , GLint )>(context->getProcAddress("glFramebufferTexture1D"));
-    CheckFramebufferStatus = reinterpret_cast<GLenum (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glCheckFramebufferStatus"));
-    GenFramebuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glGenFramebuffers"));
-    DeleteFramebuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *)>(context->getProcAddress("glDeleteFramebuffers"));
-    BindFramebuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glBindFramebuffer"));
-    IsFramebuffer = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glIsFramebuffer"));
-    GetRenderbufferParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress("glGetRenderbufferParameteriv"));
-    RenderbufferStorage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLsizei , GLsizei )>(context->getProcAddress("glRenderbufferStorage"));
-    GenRenderbuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glGenRenderbuffers"));
-    DeleteRenderbuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *)>(context->getProcAddress("glDeleteRenderbuffers"));
-    BindRenderbuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glBindRenderbuffer"));
-    IsRenderbuffer = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glIsRenderbuffer"));
-    GetStringi = reinterpret_cast<const GLubyte * (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glGetStringi"));
-    ClearBufferfi = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLfloat , GLint )>(context->getProcAddress("glClearBufferfi"));
-    ClearBufferfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , const GLfloat *)>(context->getProcAddress("glClearBufferfv"));
-    ClearBufferuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , const GLuint *)>(context->getProcAddress("glClearBufferuiv"));
-    ClearBufferiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , const GLint *)>(context->getProcAddress("glClearBufferiv"));
-    GetTexParameterIuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint *)>(context->getProcAddress("glGetTexParameterIuiv"));
-    GetTexParameterIiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress("glGetTexParameterIiv"));
-    TexParameterIuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glTexParameterIuiv"));
-    TexParameterIiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(context->getProcAddress("glTexParameterIiv"));
-    Uniform4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , const GLuint *)>(context->getProcAddress("glUniform4uiv"));
-    Uniform3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , const GLuint *)>(context->getProcAddress("glUniform3uiv"));
-    Uniform2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , const GLuint *)>(context->getProcAddress("glUniform2uiv"));
-    Uniform1uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , const GLuint *)>(context->getProcAddress("glUniform1uiv"));
-    Uniform4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLuint , GLuint , GLuint , GLuint )>(context->getProcAddress("glUniform4ui"));
-    Uniform3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLuint , GLuint , GLuint )>(context->getProcAddress("glUniform3ui"));
-    Uniform2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLuint , GLuint )>(context->getProcAddress("glUniform2ui"));
-    Uniform1ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLuint )>(context->getProcAddress("glUniform1ui"));
-    GetFragDataLocation = reinterpret_cast<GLint (QOPENGLF_APIENTRYP)(GLuint , const GLchar *)>(context->getProcAddress("glGetFragDataLocation"));
-    BindFragDataLocation = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , const GLchar *)>(context->getProcAddress("glBindFragDataLocation"));
-    GetUniformuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLuint *)>(context->getProcAddress("glGetUniformuiv"));
-    VertexAttribI4usv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLushort *)>(context->getProcAddress("glVertexAttribI4usv"));
-    VertexAttribI4ubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLubyte *)>(context->getProcAddress("glVertexAttribI4ubv"));
-    VertexAttribI4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttribI4sv"));
-    VertexAttribI4bv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLbyte *)>(context->getProcAddress("glVertexAttribI4bv"));
-    VertexAttribI4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttribI4uiv"));
-    VertexAttribI3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttribI3uiv"));
-    VertexAttribI2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttribI2uiv"));
-    VertexAttribI1uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttribI1uiv"));
-    VertexAttribI4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttribI4iv"));
-    VertexAttribI3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttribI3iv"));
-    VertexAttribI2iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttribI2iv"));
-    VertexAttribI1iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttribI1iv"));
-    VertexAttribI4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint , GLuint , GLuint )>(context->getProcAddress("glVertexAttribI4ui"));
-    VertexAttribI3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint , GLuint )>(context->getProcAddress("glVertexAttribI3ui"));
-    VertexAttribI2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint )>(context->getProcAddress("glVertexAttribI2ui"));
-    VertexAttribI1ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glVertexAttribI1ui"));
-    VertexAttribI4i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint )>(context->getProcAddress("glVertexAttribI4i"));
-    VertexAttribI3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint )>(context->getProcAddress("glVertexAttribI3i"));
-    VertexAttribI2i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint )>(context->getProcAddress("glVertexAttribI2i"));
-    VertexAttribI1i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint )>(context->getProcAddress("glVertexAttribI1i"));
-    GetVertexAttribIuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint *)>(context->getProcAddress("glGetVertexAttribIuiv"));
-    GetVertexAttribIiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetVertexAttribIiv"));
-    VertexAttribIPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glVertexAttribIPointer"));
-    EndConditionalRender = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glEndConditionalRender"));
-    BeginConditionalRender = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress("glBeginConditionalRender"));
-    ClampColor = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum )>(context->getProcAddress("glClampColor"));
-    GetTransformFeedbackVarying = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLsizei , GLsizei *, GLsizei *, GLenum *, GLchar *)>(context->getProcAddress("glGetTransformFeedbackVarying"));
-    TransformFeedbackVaryings = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLchar* const *, GLenum )>(context->getProcAddress("glTransformFeedbackVaryings"));
-    BindBufferBase = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLuint )>(context->getProcAddress("glBindBufferBase"));
-    BindBufferRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLuint , GLintptr , GLsizeiptr )>(context->getProcAddress("glBindBufferRange"));
-    EndTransformFeedback = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glEndTransformFeedback"));
-    BeginTransformFeedback = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glBeginTransformFeedback"));
-    IsEnabledi = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glIsEnabledi"));
-    Disablei = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glDisablei"));
-    Enablei = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glEnablei"));
-    GetIntegeri_v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLint *)>(context->getProcAddress("glGetIntegeri_v"));
-    GetBooleani_v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLboolean *)>(context->getProcAddress("glGetBooleani_v"));
-    ColorMaski = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLboolean , GLboolean , GLboolean , GLboolean )>(context->getProcAddress("glColorMaski"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_3_0_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(3, 0, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_3_1_CoreBackend::QOpenGLFunctions_3_1_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 3.1 core functions
-    CopyBufferSubData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLintptr , GLintptr , GLsizeiptr )>(context->getProcAddress("glCopyBufferSubData"));
-    UniformBlockBinding = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint )>(context->getProcAddress("glUniformBlockBinding"));
-    GetActiveUniformBlockName = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLsizei , GLsizei *, GLchar *)>(context->getProcAddress("glGetActiveUniformBlockName"));
-    GetActiveUniformBlockiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLenum , GLint *)>(context->getProcAddress("glGetActiveUniformBlockiv"));
-    GetUniformBlockIndex = reinterpret_cast<GLuint (QOPENGLF_APIENTRYP)(GLuint , const GLchar *)>(context->getProcAddress("glGetUniformBlockIndex"));
-    GetActiveUniformName = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLsizei , GLsizei *, GLchar *)>(context->getProcAddress("glGetActiveUniformName"));
-    GetActiveUniformsiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLuint *, GLenum , GLint *)>(context->getProcAddress("glGetActiveUniformsiv"));
-    GetUniformIndices = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLchar* const *, GLuint *)>(context->getProcAddress("glGetUniformIndices"));
-    PrimitiveRestartIndex = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glPrimitiveRestartIndex"));
-    TexBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glTexBuffer"));
-    DrawElementsInstanced = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , const GLvoid *, GLsizei )>(context->getProcAddress("glDrawElementsInstanced"));
-    DrawArraysInstanced = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLsizei , GLsizei )>(context->getProcAddress("glDrawArraysInstanced"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_3_1_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(3, 1, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_3_2_CoreBackend::QOpenGLFunctions_3_2_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 3.2 core functions
-    SampleMaski = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLbitfield )>(context->getProcAddress("glSampleMaski"));
-    GetMultisamplefv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLfloat *)>(context->getProcAddress("glGetMultisamplefv"));
-    TexImage3DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexImage3DMultisample"));
-    TexImage2DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexImage2DMultisample"));
-    GetSynciv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsync , GLenum , GLsizei , GLsizei *, GLint *)>(context->getProcAddress("glGetSynciv"));
-    GetInteger64v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint64 *)>(context->getProcAddress("glGetInteger64v"));
-    WaitSync = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsync , GLbitfield , GLuint64 )>(context->getProcAddress("glWaitSync"));
-    ClientWaitSync = reinterpret_cast<GLenum (QOPENGLF_APIENTRYP)(GLsync , GLbitfield , GLuint64 )>(context->getProcAddress("glClientWaitSync"));
-    DeleteSync = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsync )>(context->getProcAddress("glDeleteSync"));
-    IsSync = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLsync )>(context->getProcAddress("glIsSync"));
-    FenceSync = reinterpret_cast<GLsync (QOPENGLF_APIENTRYP)(GLenum , GLbitfield )>(context->getProcAddress("glFenceSync"));
-    ProvokingVertex = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glProvokingVertex"));
-    MultiDrawElementsBaseVertex = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLsizei *, GLenum , const GLvoid* const *, GLsizei , const GLint *)>(context->getProcAddress("glMultiDrawElementsBaseVertex"));
-    DrawElementsInstancedBaseVertex = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , const GLvoid *, GLsizei , GLint )>(context->getProcAddress("glDrawElementsInstancedBaseVertex"));
-    DrawRangeElementsBaseVertex = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLuint , GLsizei , GLenum , const GLvoid *, GLint )>(context->getProcAddress("glDrawRangeElementsBaseVertex"));
-    DrawElementsBaseVertex = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , const GLvoid *, GLint )>(context->getProcAddress("glDrawElementsBaseVertex"));
-    FramebufferTexture = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint , GLint )>(context->getProcAddress("glFramebufferTexture"));
-    GetBufferParameteri64v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint64 *)>(context->getProcAddress("glGetBufferParameteri64v"));
-    GetInteger64i_v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLint64 *)>(context->getProcAddress("glGetInteger64i_v"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_3_2_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(3, 2, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_3_3_CoreBackend::QOpenGLFunctions_3_3_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 3.3 core functions
-    VertexAttribP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLboolean , const GLuint *)>(context->getProcAddress("glVertexAttribP4uiv"));
-    VertexAttribP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLboolean , GLuint )>(context->getProcAddress("glVertexAttribP4ui"));
-    VertexAttribP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLboolean , const GLuint *)>(context->getProcAddress("glVertexAttribP3uiv"));
-    VertexAttribP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLboolean , GLuint )>(context->getProcAddress("glVertexAttribP3ui"));
-    VertexAttribP2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLboolean , const GLuint *)>(context->getProcAddress("glVertexAttribP2uiv"));
-    VertexAttribP2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLboolean , GLuint )>(context->getProcAddress("glVertexAttribP2ui"));
-    VertexAttribP1uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLboolean , const GLuint *)>(context->getProcAddress("glVertexAttribP1uiv"));
-    VertexAttribP1ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLboolean , GLuint )>(context->getProcAddress("glVertexAttribP1ui"));
-    SecondaryColorP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glSecondaryColorP3uiv"));
-    SecondaryColorP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glSecondaryColorP3ui"));
-    ColorP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glColorP4uiv"));
-    ColorP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glColorP4ui"));
-    ColorP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glColorP3uiv"));
-    ColorP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glColorP3ui"));
-    NormalP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glNormalP3uiv"));
-    NormalP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glNormalP3ui"));
-    MultiTexCoordP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glMultiTexCoordP4uiv"));
-    MultiTexCoordP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glMultiTexCoordP4ui"));
-    MultiTexCoordP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glMultiTexCoordP3uiv"));
-    MultiTexCoordP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glMultiTexCoordP3ui"));
-    MultiTexCoordP2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glMultiTexCoordP2uiv"));
-    MultiTexCoordP2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glMultiTexCoordP2ui"));
-    MultiTexCoordP1uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glMultiTexCoordP1uiv"));
-    MultiTexCoordP1ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glMultiTexCoordP1ui"));
-    TexCoordP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glTexCoordP4uiv"));
-    TexCoordP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glTexCoordP4ui"));
-    TexCoordP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glTexCoordP3uiv"));
-    TexCoordP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glTexCoordP3ui"));
-    TexCoordP2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glTexCoordP2uiv"));
-    TexCoordP2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glTexCoordP2ui"));
-    TexCoordP1uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glTexCoordP1uiv"));
-    TexCoordP1ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glTexCoordP1ui"));
-    VertexP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glVertexP4uiv"));
-    VertexP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glVertexP4ui"));
-    VertexP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glVertexP3uiv"));
-    VertexP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glVertexP3ui"));
-    VertexP2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glVertexP2uiv"));
-    VertexP2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glVertexP2ui"));
-    GetQueryObjectui64v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint64 *)>(context->getProcAddress("glGetQueryObjectui64v"));
-    GetQueryObjecti64v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint64 *)>(context->getProcAddress("glGetQueryObjecti64v"));
-    QueryCounter = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress("glQueryCounter"));
-    GetSamplerParameterIuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint *)>(context->getProcAddress("glGetSamplerParameterIuiv"));
-    GetSamplerParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLfloat *)>(context->getProcAddress("glGetSamplerParameterfv"));
-    GetSamplerParameterIiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetSamplerParameterIiv"));
-    GetSamplerParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetSamplerParameteriv"));
-    SamplerParameterIuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLuint *)>(context->getProcAddress("glSamplerParameterIuiv"));
-    SamplerParameterIiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLint *)>(context->getProcAddress("glSamplerParameterIiv"));
-    SamplerParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLfloat *)>(context->getProcAddress("glSamplerParameterfv"));
-    SamplerParameterf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLfloat )>(context->getProcAddress("glSamplerParameterf"));
-    SamplerParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLint *)>(context->getProcAddress("glSamplerParameteriv"));
-    SamplerParameteri = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint )>(context->getProcAddress("glSamplerParameteri"));
-    BindSampler = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glBindSampler"));
-    IsSampler = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glIsSampler"));
-    DeleteSamplers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *)>(context->getProcAddress("glDeleteSamplers"));
-    GenSamplers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glGenSamplers"));
-    GetFragDataIndex = reinterpret_cast<GLint (QOPENGLF_APIENTRYP)(GLuint , const GLchar *)>(context->getProcAddress("glGetFragDataIndex"));
-    BindFragDataLocationIndexed = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint , const GLchar *)>(context->getProcAddress("glBindFragDataLocationIndexed"));
-    VertexAttribDivisor = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glVertexAttribDivisor"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_3_3_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(3, 3, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_4_0_CoreBackend::QOpenGLFunctions_4_0_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 4.0 core functions
-    GetQueryIndexediv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLenum , GLint *)>(context->getProcAddress("glGetQueryIndexediv"));
-    EndQueryIndexed = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glEndQueryIndexed"));
-    BeginQueryIndexed = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLuint )>(context->getProcAddress("glBeginQueryIndexed"));
-    DrawTransformFeedbackStream = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLuint )>(context->getProcAddress("glDrawTransformFeedbackStream"));
-    DrawTransformFeedback = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glDrawTransformFeedback"));
-    ResumeTransformFeedback = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glResumeTransformFeedback"));
-    PauseTransformFeedback = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glPauseTransformFeedback"));
-    IsTransformFeedback = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glIsTransformFeedback"));
-    GenTransformFeedbacks = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glGenTransformFeedbacks"));
-    DeleteTransformFeedbacks = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *)>(context->getProcAddress("glDeleteTransformFeedbacks"));
-    BindTransformFeedback = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glBindTransformFeedback"));
-    PatchParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLfloat *)>(context->getProcAddress("glPatchParameterfv"));
-    PatchParameteri = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(context->getProcAddress("glPatchParameteri"));
-    GetProgramStageiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLint *)>(context->getProcAddress("glGetProgramStageiv"));
-    GetUniformSubroutineuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLuint *)>(context->getProcAddress("glGetUniformSubroutineuiv"));
-    UniformSubroutinesuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLuint *)>(context->getProcAddress("glUniformSubroutinesuiv"));
-    GetActiveSubroutineName = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLsizei , GLsizei *, GLchar *)>(context->getProcAddress("glGetActiveSubroutineName"));
-    GetActiveSubroutineUniformName = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLsizei , GLsizei *, GLchar *)>(context->getProcAddress("glGetActiveSubroutineUniformName"));
-    GetActiveSubroutineUniformiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLenum , GLint *)>(context->getProcAddress("glGetActiveSubroutineUniformiv"));
-    GetSubroutineIndex = reinterpret_cast<GLuint (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLchar *)>(context->getProcAddress("glGetSubroutineIndex"));
-    GetSubroutineUniformLocation = reinterpret_cast<GLint (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLchar *)>(context->getProcAddress("glGetSubroutineUniformLocation"));
-    GetUniformdv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLdouble *)>(context->getProcAddress("glGetUniformdv"));
-    UniformMatrix4x3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glUniformMatrix4x3dv"));
-    UniformMatrix4x2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glUniformMatrix4x2dv"));
-    UniformMatrix3x4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glUniformMatrix3x4dv"));
-    UniformMatrix3x2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glUniformMatrix3x2dv"));
-    UniformMatrix2x4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glUniformMatrix2x4dv"));
-    UniformMatrix2x3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glUniformMatrix2x3dv"));
-    UniformMatrix4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glUniformMatrix4dv"));
-    UniformMatrix3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glUniformMatrix3dv"));
-    UniformMatrix2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glUniformMatrix2dv"));
-    Uniform4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , const GLdouble *)>(context->getProcAddress("glUniform4dv"));
-    Uniform3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , const GLdouble *)>(context->getProcAddress("glUniform3dv"));
-    Uniform2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , const GLdouble *)>(context->getProcAddress("glUniform2dv"));
-    Uniform1dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLsizei , const GLdouble *)>(context->getProcAddress("glUniform1dv"));
-    Uniform4d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLdouble , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glUniform4d"));
-    Uniform3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glUniform3d"));
-    Uniform2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLdouble , GLdouble )>(context->getProcAddress("glUniform2d"));
-    Uniform1d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLdouble )>(context->getProcAddress("glUniform1d"));
-    DrawElementsIndirect = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glDrawElementsIndirect"));
-    DrawArraysIndirect = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLvoid *)>(context->getProcAddress("glDrawArraysIndirect"));
-    BlendFuncSeparatei = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLenum , GLenum )>(context->getProcAddress("glBlendFuncSeparatei"));
-    BlendFunci = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum )>(context->getProcAddress("glBlendFunci"));
-    BlendEquationSeparatei = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum )>(context->getProcAddress("glBlendEquationSeparatei"));
-    BlendEquationi = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress("glBlendEquationi"));
-    MinSampleShading = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(context->getProcAddress("glMinSampleShading"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_4_0_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(4, 0, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_4_1_CoreBackend::QOpenGLFunctions_4_1_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 4.1 core functions
-    GetDoublei_v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLdouble *)>(context->getProcAddress("glGetDoublei_v"));
-    GetFloati_v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLfloat *)>(context->getProcAddress("glGetFloati_v"));
-    DepthRangeIndexed = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble , GLdouble )>(context->getProcAddress("glDepthRangeIndexed"));
-    DepthRangeArrayv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLdouble *)>(context->getProcAddress("glDepthRangeArrayv"));
-    ScissorIndexedv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glScissorIndexedv"));
-    ScissorIndexed = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLsizei , GLsizei )>(context->getProcAddress("glScissorIndexed"));
-    ScissorArrayv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLint *)>(context->getProcAddress("glScissorArrayv"));
-    ViewportIndexedfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glViewportIndexedfv"));
-    ViewportIndexedf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glViewportIndexedf"));
-    ViewportArrayv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLfloat *)>(context->getProcAddress("glViewportArrayv"));
-    GetVertexAttribLdv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLdouble *)>(context->getProcAddress("glGetVertexAttribLdv"));
-    VertexAttribLPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glVertexAttribLPointer"));
-    VertexAttribL4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttribL4dv"));
-    VertexAttribL3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttribL3dv"));
-    VertexAttribL2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttribL2dv"));
-    VertexAttribL1dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttribL1dv"));
-    VertexAttribL4d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glVertexAttribL4d"));
-    VertexAttribL3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glVertexAttribL3d"));
-    VertexAttribL2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble , GLdouble )>(context->getProcAddress("glVertexAttribL2d"));
-    VertexAttribL1d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble )>(context->getProcAddress("glVertexAttribL1d"));
-    GetProgramPipelineInfoLog = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLsizei *, GLchar *)>(context->getProcAddress("glGetProgramPipelineInfoLog"));
-    ValidateProgramPipeline = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glValidateProgramPipeline"));
-    ProgramUniformMatrix4x3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glProgramUniformMatrix4x3dv"));
-    ProgramUniformMatrix3x4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glProgramUniformMatrix3x4dv"));
-    ProgramUniformMatrix4x2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glProgramUniformMatrix4x2dv"));
-    ProgramUniformMatrix2x4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glProgramUniformMatrix2x4dv"));
-    ProgramUniformMatrix3x2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glProgramUniformMatrix3x2dv"));
-    ProgramUniformMatrix2x3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glProgramUniformMatrix2x3dv"));
-    ProgramUniformMatrix4x3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glProgramUniformMatrix4x3fv"));
-    ProgramUniformMatrix3x4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glProgramUniformMatrix3x4fv"));
-    ProgramUniformMatrix4x2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glProgramUniformMatrix4x2fv"));
-    ProgramUniformMatrix2x4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glProgramUniformMatrix2x4fv"));
-    ProgramUniformMatrix3x2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glProgramUniformMatrix3x2fv"));
-    ProgramUniformMatrix2x3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glProgramUniformMatrix2x3fv"));
-    ProgramUniformMatrix4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glProgramUniformMatrix4dv"));
-    ProgramUniformMatrix3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glProgramUniformMatrix3dv"));
-    ProgramUniformMatrix2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLdouble *)>(context->getProcAddress("glProgramUniformMatrix2dv"));
-    ProgramUniformMatrix4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glProgramUniformMatrix4fv"));
-    ProgramUniformMatrix3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glProgramUniformMatrix3fv"));
-    ProgramUniformMatrix2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLboolean , const GLfloat *)>(context->getProcAddress("glProgramUniformMatrix2fv"));
-    ProgramUniform4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , const GLuint *)>(context->getProcAddress("glProgramUniform4uiv"));
-    ProgramUniform4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLuint , GLuint , GLuint , GLuint )>(context->getProcAddress("glProgramUniform4ui"));
-    ProgramUniform4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , const GLdouble *)>(context->getProcAddress("glProgramUniform4dv"));
-    ProgramUniform4d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLdouble , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glProgramUniform4d"));
-    ProgramUniform4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , const GLfloat *)>(context->getProcAddress("glProgramUniform4fv"));
-    ProgramUniform4f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glProgramUniform4f"));
-    ProgramUniform4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , const GLint *)>(context->getProcAddress("glProgramUniform4iv"));
-    ProgramUniform4i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLint )>(context->getProcAddress("glProgramUniform4i"));
-    ProgramUniform3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , const GLuint *)>(context->getProcAddress("glProgramUniform3uiv"));
-    ProgramUniform3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLuint , GLuint , GLuint )>(context->getProcAddress("glProgramUniform3ui"));
-    ProgramUniform3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , const GLdouble *)>(context->getProcAddress("glProgramUniform3dv"));
-    ProgramUniform3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glProgramUniform3d"));
-    ProgramUniform3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , const GLfloat *)>(context->getProcAddress("glProgramUniform3fv"));
-    ProgramUniform3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glProgramUniform3f"));
-    ProgramUniform3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , const GLint *)>(context->getProcAddress("glProgramUniform3iv"));
-    ProgramUniform3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint )>(context->getProcAddress("glProgramUniform3i"));
-    ProgramUniform2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , const GLuint *)>(context->getProcAddress("glProgramUniform2uiv"));
-    ProgramUniform2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLuint , GLuint )>(context->getProcAddress("glProgramUniform2ui"));
-    ProgramUniform2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , const GLdouble *)>(context->getProcAddress("glProgramUniform2dv"));
-    ProgramUniform2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLdouble , GLdouble )>(context->getProcAddress("glProgramUniform2d"));
-    ProgramUniform2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , const GLfloat *)>(context->getProcAddress("glProgramUniform2fv"));
-    ProgramUniform2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLfloat , GLfloat )>(context->getProcAddress("glProgramUniform2f"));
-    ProgramUniform2iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , const GLint *)>(context->getProcAddress("glProgramUniform2iv"));
-    ProgramUniform2i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint )>(context->getProcAddress("glProgramUniform2i"));
-    ProgramUniform1uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , const GLuint *)>(context->getProcAddress("glProgramUniform1uiv"));
-    ProgramUniform1ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLuint )>(context->getProcAddress("glProgramUniform1ui"));
-    ProgramUniform1dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , const GLdouble *)>(context->getProcAddress("glProgramUniform1dv"));
-    ProgramUniform1d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLdouble )>(context->getProcAddress("glProgramUniform1d"));
-    ProgramUniform1fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , const GLfloat *)>(context->getProcAddress("glProgramUniform1fv"));
-    ProgramUniform1f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLfloat )>(context->getProcAddress("glProgramUniform1f"));
-    ProgramUniform1iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , const GLint *)>(context->getProcAddress("glProgramUniform1iv"));
-    ProgramUniform1i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint )>(context->getProcAddress("glProgramUniform1i"));
-    GetProgramPipelineiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetProgramPipelineiv"));
-    IsProgramPipeline = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glIsProgramPipeline"));
-    GenProgramPipelines = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glGenProgramPipelines"));
-    DeleteProgramPipelines = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *)>(context->getProcAddress("glDeleteProgramPipelines"));
-    BindProgramPipeline = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glBindProgramPipeline"));
-    CreateShaderProgramv = reinterpret_cast<GLuint (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLchar* const *)>(context->getProcAddress("glCreateShaderProgramv"));
-    ActiveShaderProgram = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glActiveShaderProgram"));
-    UseProgramStages = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLbitfield , GLuint )>(context->getProcAddress("glUseProgramStages"));
-    ProgramParameteri = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint )>(context->getProcAddress("glProgramParameteri"));
-    ProgramBinary = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLvoid *, GLsizei )>(context->getProcAddress("glProgramBinary"));
-    GetProgramBinary = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLsizei *, GLenum *, GLvoid *)>(context->getProcAddress("glGetProgramBinary"));
-    ClearDepthf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(context->getProcAddress("glClearDepthf"));
-    DepthRangef = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(context->getProcAddress("glDepthRangef"));
-    GetShaderPrecisionFormat = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *, GLint *)>(context->getProcAddress("glGetShaderPrecisionFormat"));
-    ShaderBinary = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *, GLenum , const GLvoid *, GLsizei )>(context->getProcAddress("glShaderBinary"));
-    ReleaseShaderCompiler = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glReleaseShaderCompiler"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_4_1_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(4, 1, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_4_2_CoreBackend::QOpenGLFunctions_4_2_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 4.2 core functions
-    TexStorage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei )>(context->getProcAddress("glTexStorage3D"));
-    TexStorage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei )>(context->getProcAddress("glTexStorage2D"));
-    TexStorage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei )>(context->getProcAddress("glTexStorage1D"));
-    MemoryBarrier = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbitfield )>(context->getProcAddress("glMemoryBarrier"));
-    BindImageTexture = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLint , GLboolean , GLint , GLenum , GLenum )>(context->getProcAddress("glBindImageTexture"));
-    GetActiveAtomicCounterBufferiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLenum , GLint *)>(context->getProcAddress("glGetActiveAtomicCounterBufferiv"));
-    GetInternalformativ = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLsizei , GLint *)>(context->getProcAddress("glGetInternalformativ"));
-    DrawTransformFeedbackStreamInstanced = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLuint , GLsizei )>(context->getProcAddress("glDrawTransformFeedbackStreamInstanced"));
-    DrawTransformFeedbackInstanced = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLsizei )>(context->getProcAddress("glDrawTransformFeedbackInstanced"));
-    DrawElementsInstancedBaseVertexBaseInstance = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , const void *, GLsizei , GLint , GLuint )>(context->getProcAddress("glDrawElementsInstancedBaseVertexBaseInstance"));
-    DrawElementsInstancedBaseInstance = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , const void *, GLsizei , GLuint )>(context->getProcAddress("glDrawElementsInstancedBaseInstance"));
-    DrawArraysInstancedBaseInstance = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLsizei , GLsizei , GLuint )>(context->getProcAddress("glDrawArraysInstancedBaseInstance"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_4_2_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(4, 2, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_4_3_CoreBackend::QOpenGLFunctions_4_3_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 4.3 core functions
-    GetObjectPtrLabel = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const void *, GLsizei , GLsizei *, GLchar *)>(context->getProcAddress("glGetObjectPtrLabel"));
-    ObjectPtrLabel = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const void *, GLsizei , const GLchar *)>(context->getProcAddress("glObjectPtrLabel"));
-    GetObjectLabel = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLsizei , GLsizei *, GLchar *)>(context->getProcAddress("glGetObjectLabel"));
-    ObjectLabel = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLsizei , const GLchar *)>(context->getProcAddress("glObjectLabel"));
-    PopDebugGroup = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glPopDebugGroup"));
-    PushDebugGroup = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLsizei , const GLchar *)>(context->getProcAddress("glPushDebugGroup"));
-    GetDebugMessageLog = reinterpret_cast<GLuint (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLenum *, GLenum *, GLuint *, GLenum *, GLsizei *, GLchar *)>(context->getProcAddress("glGetDebugMessageLog"));
-    DebugMessageCallback = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLDEBUGPROC , const void *)>(context->getProcAddress("glDebugMessageCallback"));
-    DebugMessageInsert = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint , GLenum , GLsizei , const GLchar *)>(context->getProcAddress("glDebugMessageInsert"));
-    DebugMessageControl = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLsizei , const GLuint *, GLboolean )>(context->getProcAddress("glDebugMessageControl"));
-    TexStorage3DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexStorage3DMultisample"));
-    TexStorage2DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTexStorage2DMultisample"));
-    TexBufferRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint , GLintptr , GLsizeiptr )>(context->getProcAddress("glTexBufferRange"));
-    ShaderStorageBlockBinding = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint )>(context->getProcAddress("glShaderStorageBlockBinding"));
-    GetProgramResourceLocationIndex = reinterpret_cast<GLint (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLchar *)>(context->getProcAddress("glGetProgramResourceLocationIndex"));
-    GetProgramResourceLocation = reinterpret_cast<GLint (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLchar *)>(context->getProcAddress("glGetProgramResourceLocation"));
-    GetProgramResourceiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLsizei , const GLenum *, GLsizei , GLsizei *, GLint *)>(context->getProcAddress("glGetProgramResourceiv"));
-    GetProgramResourceName = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLsizei , GLsizei *, GLchar *)>(context->getProcAddress("glGetProgramResourceName"));
-    GetProgramResourceIndex = reinterpret_cast<GLuint (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLchar *)>(context->getProcAddress("glGetProgramResourceIndex"));
-    GetProgramInterfaceiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLint *)>(context->getProcAddress("glGetProgramInterfaceiv"));
-    MultiDrawElementsIndirect = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const void *, GLsizei , GLsizei )>(context->getProcAddress("glMultiDrawElementsIndirect"));
-    MultiDrawArraysIndirect = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const void *, GLsizei , GLsizei )>(context->getProcAddress("glMultiDrawArraysIndirect"));
-    InvalidateSubFramebuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLenum *, GLint , GLint , GLsizei , GLsizei )>(context->getProcAddress("glInvalidateSubFramebuffer"));
-    InvalidateFramebuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLenum *)>(context->getProcAddress("glInvalidateFramebuffer"));
-    InvalidateBufferData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glInvalidateBufferData"));
-    InvalidateBufferSubData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLintptr , GLsizeiptr )>(context->getProcAddress("glInvalidateBufferSubData"));
-    InvalidateTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint )>(context->getProcAddress("glInvalidateTexImage"));
-    InvalidateTexSubImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei )>(context->getProcAddress("glInvalidateTexSubImage"));
-    GetInternalformati64v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLsizei , GLint64 *)>(context->getProcAddress("glGetInternalformati64v"));
-    GetFramebufferParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress("glGetFramebufferParameteriv"));
-    FramebufferParameteri = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint )>(context->getProcAddress("glFramebufferParameteri"));
-    VertexBindingDivisor = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glVertexBindingDivisor"));
-    VertexAttribBinding = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glVertexAttribBinding"));
-    VertexAttribLFormat = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLenum , GLuint )>(context->getProcAddress("glVertexAttribLFormat"));
-    VertexAttribIFormat = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLenum , GLuint )>(context->getProcAddress("glVertexAttribIFormat"));
-    VertexAttribFormat = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLenum , GLboolean , GLuint )>(context->getProcAddress("glVertexAttribFormat"));
-    BindVertexBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLintptr , GLsizei )>(context->getProcAddress("glBindVertexBuffer"));
-    TextureView = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLenum , GLuint , GLuint , GLuint , GLuint )>(context->getProcAddress("glTextureView"));
-    CopyImageSubData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , GLint , GLint , GLint , GLuint , GLenum , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei )>(context->getProcAddress("glCopyImageSubData"));
-    DispatchComputeIndirect = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLintptr )>(context->getProcAddress("glDispatchComputeIndirect"));
-    DispatchCompute = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint )>(context->getProcAddress("glDispatchCompute"));
-    ClearBufferSubData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLintptr , GLsizeiptr , GLenum , GLenum , const void *)>(context->getProcAddress("glClearBufferSubData"));
-    ClearBufferData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLenum , const void *)>(context->getProcAddress("glClearBufferData"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_4_3_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(4, 3, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_4_4_CoreBackend::QOpenGLFunctions_4_4_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 4.4 core functions
-    BindVertexBuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLuint *, const GLintptr *, const GLsizei *)>(context->getProcAddress("glBindVertexBuffers"));
-    BindImageTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLuint *)>(context->getProcAddress("glBindImageTextures"));
-    BindSamplers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLuint *)>(context->getProcAddress("glBindSamplers"));
-    BindTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLuint *)>(context->getProcAddress("glBindTextures"));
-    BindBuffersRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLsizei , const GLuint *, const GLintptr *, const GLsizeiptr *)>(context->getProcAddress("glBindBuffersRange"));
-    BindBuffersBase = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint , GLsizei , const GLuint *)>(context->getProcAddress("glBindBuffersBase"));
-    ClearTexSubImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const void *)>(context->getProcAddress("glClearTexSubImage"));
-    ClearTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLenum , GLenum , const void *)>(context->getProcAddress("glClearTexImage"));
-    BufferStorage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizeiptr , const void *, GLbitfield )>(context->getProcAddress("glBufferStorage"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_4_4_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(4, 4, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_4_5_CoreBackend::QOpenGLFunctions_4_5_CoreBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 4.5 core functions
-    TextureBarrier = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glTextureBarrier"));
-    ReadnPixels = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , GLsizei , void *)>(context->getProcAddress("glReadnPixels"));
-    GetnUniformuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLuint *)>(context->getProcAddress("glGetnUniformuiv"));
-    GetnUniformiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLint *)>(context->getProcAddress("glGetnUniformiv"));
-    GetnUniformfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLfloat *)>(context->getProcAddress("glGetnUniformfv"));
-    GetnUniformdv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , GLdouble *)>(context->getProcAddress("glGetnUniformdv"));
-    GetnTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLenum , GLenum , GLsizei , void *)>(context->getProcAddress("glGetnTexImage"));
-    GetnCompressedTexImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLsizei , void *)>(context->getProcAddress("glGetnCompressedTexImage"));
-    GetGraphicsResetStatus = reinterpret_cast<GLenum (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glGetGraphicsResetStatus"));
-    GetCompressedTextureSubImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLsizei , void *)>(context->getProcAddress("glGetCompressedTextureSubImage"));
-    GetTextureSubImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , GLsizei , void *)>(context->getProcAddress("glGetTextureSubImage"));
-    MemoryBarrierByRegion = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbitfield )>(context->getProcAddress("glMemoryBarrierByRegion"));
-    CreateQueries = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLuint *)>(context->getProcAddress("glCreateQueries"));
-    CreateProgramPipelines = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glCreateProgramPipelines"));
-    CreateSamplers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glCreateSamplers"));
-    GetVertexArrayIndexed64iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLenum , GLint64 *)>(context->getProcAddress("glGetVertexArrayIndexed64iv"));
-    GetVertexArrayIndexediv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLenum , GLint *)>(context->getProcAddress("glGetVertexArrayIndexediv"));
-    GetVertexArrayiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetVertexArrayiv"));
-    VertexArrayBindingDivisor = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint )>(context->getProcAddress("glVertexArrayBindingDivisor"));
-    VertexArrayAttribLFormat = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLint , GLenum , GLuint )>(context->getProcAddress("glVertexArrayAttribLFormat"));
-    VertexArrayAttribIFormat = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLint , GLenum , GLuint )>(context->getProcAddress("glVertexArrayAttribIFormat"));
-    VertexArrayAttribFormat = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLint , GLenum , GLboolean , GLuint )>(context->getProcAddress("glVertexArrayAttribFormat"));
-    VertexArrayAttribBinding = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint )>(context->getProcAddress("glVertexArrayAttribBinding"));
-    VertexArrayVertexBuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLsizei , const GLuint *, const GLintptr *, const GLsizei *)>(context->getProcAddress("glVertexArrayVertexBuffers"));
-    VertexArrayVertexBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint , GLintptr , GLsizei )>(context->getProcAddress("glVertexArrayVertexBuffer"));
-    VertexArrayElementBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glVertexArrayElementBuffer"));
-    EnableVertexArrayAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glEnableVertexArrayAttrib"));
-    DisableVertexArrayAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glDisableVertexArrayAttrib"));
-    CreateVertexArrays = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glCreateVertexArrays"));
-    GetTextureParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetTextureParameteriv"));
-    GetTextureParameterIuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint *)>(context->getProcAddress("glGetTextureParameterIuiv"));
-    GetTextureParameterIiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetTextureParameterIiv"));
-    GetTextureParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLfloat *)>(context->getProcAddress("glGetTextureParameterfv"));
-    GetTextureLevelParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLenum , GLint *)>(context->getProcAddress("glGetTextureLevelParameteriv"));
-    GetTextureLevelParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLenum , GLfloat *)>(context->getProcAddress("glGetTextureLevelParameterfv"));
-    GetCompressedTextureImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLsizei , void *)>(context->getProcAddress("glGetCompressedTextureImage"));
-    GetTextureImage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLenum , GLenum , GLsizei , void *)>(context->getProcAddress("glGetTextureImage"));
-    BindTextureUnit = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glBindTextureUnit"));
-    GenerateTextureMipmap = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glGenerateTextureMipmap"));
-    TextureParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLint *)>(context->getProcAddress("glTextureParameteriv"));
-    TextureParameterIuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLuint *)>(context->getProcAddress("glTextureParameterIuiv"));
-    TextureParameterIiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLint *)>(context->getProcAddress("glTextureParameterIiv"));
-    TextureParameteri = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint )>(context->getProcAddress("glTextureParameteri"));
-    TextureParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , const GLfloat *)>(context->getProcAddress("glTextureParameterfv"));
-    TextureParameterf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLfloat )>(context->getProcAddress("glTextureParameterf"));
-    CopyTextureSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei )>(context->getProcAddress("glCopyTextureSubImage3D"));
-    CopyTextureSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei )>(context->getProcAddress("glCopyTextureSubImage2D"));
-    CopyTextureSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLsizei )>(context->getProcAddress("glCopyTextureSubImage1D"));
-    CompressedTextureSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLsizei , const void *)>(context->getProcAddress("glCompressedTextureSubImage3D"));
-    CompressedTextureSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLsizei , const void *)>(context->getProcAddress("glCompressedTextureSubImage2D"));
-    CompressedTextureSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLsizei , GLenum , GLsizei , const void *)>(context->getProcAddress("glCompressedTextureSubImage1D"));
-    TextureSubImage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint , GLsizei , GLsizei , GLsizei , GLenum , GLenum , const void *)>(context->getProcAddress("glTextureSubImage3D"));
-    TextureSubImage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const void *)>(context->getProcAddress("glTextureSubImage2D"));
-    TextureSubImage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLsizei , GLenum , GLenum , const void *)>(context->getProcAddress("glTextureSubImage1D"));
-    TextureStorage3DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLenum , GLsizei , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTextureStorage3DMultisample"));
-    TextureStorage2DMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLenum , GLsizei , GLsizei , GLboolean )>(context->getProcAddress("glTextureStorage2DMultisample"));
-    TextureStorage3D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLenum , GLsizei , GLsizei , GLsizei )>(context->getProcAddress("glTextureStorage3D"));
-    TextureStorage2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLenum , GLsizei , GLsizei )>(context->getProcAddress("glTextureStorage2D"));
-    TextureStorage1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLenum , GLsizei )>(context->getProcAddress("glTextureStorage1D"));
-    TextureBufferRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLintptr , GLsizei )>(context->getProcAddress("glTextureBufferRange"));
-    TextureBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint )>(context->getProcAddress("glTextureBuffer"));
-    CreateTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLuint *)>(context->getProcAddress("glCreateTextures"));
-    GetNamedRenderbufferParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetNamedRenderbufferParameteriv"));
-    NamedRenderbufferStorageMultisample = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , GLenum , GLsizei , GLsizei )>(context->getProcAddress("glNamedRenderbufferStorageMultisample"));
-    NamedRenderbufferStorage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLsizei , GLsizei )>(context->getProcAddress("glNamedRenderbufferStorage"));
-    CreateRenderbuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glCreateRenderbuffers"));
-    GetNamedFramebufferAttachmentParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLint *)>(context->getProcAddress("glGetNamedFramebufferAttachmentParameteriv"));
-    GetNamedFramebufferParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetNamedFramebufferParameteriv"));
-    CheckNamedFramebufferStatus = reinterpret_cast<GLenum (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress("glCheckNamedFramebufferStatus"));
-    BlitNamedFramebuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLint , GLint , GLint , GLint , GLint , GLint , GLint , GLint , GLbitfield , GLenum )>(context->getProcAddress("glBlitNamedFramebuffer"));
-    ClearNamedFramebufferfi = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLfloat , GLint )>(context->getProcAddress("glClearNamedFramebufferfi"));
-    ClearNamedFramebufferfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , const GLfloat *)>(context->getProcAddress("glClearNamedFramebufferfv"));
-    ClearNamedFramebufferuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , const GLuint *)>(context->getProcAddress("glClearNamedFramebufferuiv"));
-    ClearNamedFramebufferiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint , const GLint *)>(context->getProcAddress("glClearNamedFramebufferiv"));
-    InvalidateNamedFramebufferSubData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLenum *, GLint , GLint , GLsizei , GLsizei )>(context->getProcAddress("glInvalidateNamedFramebufferSubData"));
-    InvalidateNamedFramebufferData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLenum *)>(context->getProcAddress("glInvalidateNamedFramebufferData"));
-    NamedFramebufferReadBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress("glNamedFramebufferReadBuffer"));
-    NamedFramebufferDrawBuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const GLenum *)>(context->getProcAddress("glNamedFramebufferDrawBuffers"));
-    NamedFramebufferDrawBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress("glNamedFramebufferDrawBuffer"));
-    NamedFramebufferTextureLayer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLint , GLint )>(context->getProcAddress("glNamedFramebufferTextureLayer"));
-    NamedFramebufferTexture = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLint )>(context->getProcAddress("glNamedFramebufferTexture"));
-    NamedFramebufferParameteri = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint )>(context->getProcAddress("glNamedFramebufferParameteri"));
-    NamedFramebufferRenderbuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLuint )>(context->getProcAddress("glNamedFramebufferRenderbuffer"));
-    CreateFramebuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glCreateFramebuffers"));
-    GetNamedBufferSubData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLintptr , GLsizei , void *)>(context->getProcAddress("glGetNamedBufferSubData"));
-    GetNamedBufferPointerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , void * *)>(context->getProcAddress("glGetNamedBufferPointerv"));
-    GetNamedBufferParameteri64v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint64 *)>(context->getProcAddress("glGetNamedBufferParameteri64v"));
-    GetNamedBufferParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetNamedBufferParameteriv"));
-    FlushMappedNamedBufferRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLintptr , GLsizei )>(context->getProcAddress("glFlushMappedNamedBufferRange"));
-    UnmapNamedBuffer = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glUnmapNamedBuffer"));
-    MapNamedBufferRange = reinterpret_cast<void * (QOPENGLF_APIENTRYP)(GLuint , GLintptr , GLsizei , GLbitfield )>(context->getProcAddress("glMapNamedBufferRange"));
-    MapNamedBuffer = reinterpret_cast<void * (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress("glMapNamedBuffer"));
-    ClearNamedBufferSubData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLintptr , GLsizei , GLenum , GLenum , const void *)>(context->getProcAddress("glClearNamedBufferSubData"));
-    ClearNamedBufferData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLenum , GLenum , const void *)>(context->getProcAddress("glClearNamedBufferData"));
-    CopyNamedBufferSubData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLintptr , GLintptr , GLsizei )>(context->getProcAddress("glCopyNamedBufferSubData"));
-    NamedBufferSubData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLintptr , GLsizei , const void *)>(context->getProcAddress("glNamedBufferSubData"));
-    NamedBufferData = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const void *, GLenum )>(context->getProcAddress("glNamedBufferData"));
-    NamedBufferStorage = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei , const void *, GLbitfield )>(context->getProcAddress("glNamedBufferStorage"));
-    CreateBuffers = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glCreateBuffers"));
-    GetTransformFeedbacki64_v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLint64 *)>(context->getProcAddress("glGetTransformFeedbacki64_v"));
-    GetTransformFeedbacki_v = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLuint , GLint *)>(context->getProcAddress("glGetTransformFeedbacki_v"));
-    GetTransformFeedbackiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum , GLint *)>(context->getProcAddress("glGetTransformFeedbackiv"));
-    TransformFeedbackBufferRange = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint , GLintptr , GLsizei )>(context->getProcAddress("glTransformFeedbackBufferRange"));
-    TransformFeedbackBufferBase = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint )>(context->getProcAddress("glTransformFeedbackBufferBase"));
-    CreateTransformFeedbacks = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glCreateTransformFeedbacks"));
-    ClipControl = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum )>(context->getProcAddress("glClipControl"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_4_5_CoreBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(4, 5, QOpenGLVersionStatus::CoreStatus);
-}
-
-QOpenGLFunctions_1_0_DeprecatedBackend::QOpenGLFunctions_1_0_DeprecatedBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 1.0 deprecated functions
-#if defined(Q_OS_WIN)
-    HMODULE handle = static_cast<HMODULE>(QOpenGLContext::openGLModuleHandle());
-    if (!handle)
-        handle = GetModuleHandleA("opengl32.dll");
-    Translatef = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat )>(GetProcAddress(handle, "glTranslatef"));
-    Translated = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble )>(GetProcAddress(handle, "glTranslated"));
-    Scalef = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat )>(GetProcAddress(handle, "glScalef"));
-    Scaled = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble )>(GetProcAddress(handle, "glScaled"));
-    Rotatef = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(GetProcAddress(handle, "glRotatef"));
-    Rotated = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble , GLdouble )>(GetProcAddress(handle, "glRotated"));
-    PushMatrix = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(GetProcAddress(handle, "glPushMatrix"));
-    PopMatrix = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(GetProcAddress(handle, "glPopMatrix"));
-    Ortho = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble , GLdouble , GLdouble , GLdouble )>(GetProcAddress(handle, "glOrtho"));
-    MultMatrixd = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glMultMatrixd"));
-    MultMatrixf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glMultMatrixf"));
-    MatrixMode = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glMatrixMode"));
-    LoadMatrixd = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glLoadMatrixd"));
-    LoadMatrixf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glLoadMatrixf"));
-    LoadIdentity = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(GetProcAddress(handle, "glLoadIdentity"));
-    Frustum = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble , GLdouble , GLdouble , GLdouble )>(GetProcAddress(handle, "glFrustum"));
-    IsList = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(GetProcAddress(handle, "glIsList"));
-    GetTexGeniv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(GetProcAddress(handle, "glGetTexGeniv"));
-    GetTexGenfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(GetProcAddress(handle, "glGetTexGenfv"));
-    GetTexGendv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLdouble *)>(GetProcAddress(handle, "glGetTexGendv"));
-    GetTexEnviv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(GetProcAddress(handle, "glGetTexEnviv"));
-    GetTexEnvfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(GetProcAddress(handle, "glGetTexEnvfv"));
-    GetPolygonStipple = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLubyte *)>(GetProcAddress(handle, "glGetPolygonStipple"));
-    GetPixelMapusv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLushort *)>(GetProcAddress(handle, "glGetPixelMapusv"));
-    GetPixelMapuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint *)>(GetProcAddress(handle, "glGetPixelMapuiv"));
-    GetPixelMapfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat *)>(GetProcAddress(handle, "glGetPixelMapfv"));
-    GetMaterialiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(GetProcAddress(handle, "glGetMaterialiv"));
-    GetMaterialfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(GetProcAddress(handle, "glGetMaterialfv"));
-    GetMapiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(GetProcAddress(handle, "glGetMapiv"));
-    GetMapfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(GetProcAddress(handle, "glGetMapfv"));
-    GetMapdv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLdouble *)>(GetProcAddress(handle, "glGetMapdv"));
-    GetLightiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(GetProcAddress(handle, "glGetLightiv"));
-    GetLightfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(GetProcAddress(handle, "glGetLightfv"));
-    GetClipPlane = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLdouble *)>(GetProcAddress(handle, "glGetClipPlane"));
-    DrawPixels = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(GetProcAddress(handle, "glDrawPixels"));
-    CopyPixels = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLsizei , GLsizei , GLenum )>(GetProcAddress(handle, "glCopyPixels"));
-    PixelMapusv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLushort *)>(GetProcAddress(handle, "glPixelMapusv"));
-    PixelMapuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLuint *)>(GetProcAddress(handle, "glPixelMapuiv"));
-    PixelMapfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLfloat *)>(GetProcAddress(handle, "glPixelMapfv"));
-    PixelTransferi = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(GetProcAddress(handle, "glPixelTransferi"));
-    PixelTransferf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat )>(GetProcAddress(handle, "glPixelTransferf"));
-    PixelZoom = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(GetProcAddress(handle, "glPixelZoom"));
-    AlphaFunc = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat )>(GetProcAddress(handle, "glAlphaFunc"));
-    EvalPoint2 = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint )>(GetProcAddress(handle, "glEvalPoint2"));
-    EvalMesh2 = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint )>(GetProcAddress(handle, "glEvalMesh2"));
-    EvalPoint1 = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint )>(GetProcAddress(handle, "glEvalPoint1"));
-    EvalMesh1 = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint )>(GetProcAddress(handle, "glEvalMesh1"));
-    EvalCoord2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glEvalCoord2fv"));
-    EvalCoord2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(GetProcAddress(handle, "glEvalCoord2f"));
-    EvalCoord2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glEvalCoord2dv"));
-    EvalCoord2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble )>(GetProcAddress(handle, "glEvalCoord2d"));
-    EvalCoord1fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glEvalCoord1fv"));
-    EvalCoord1f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(GetProcAddress(handle, "glEvalCoord1f"));
-    EvalCoord1dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glEvalCoord1dv"));
-    EvalCoord1d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble )>(GetProcAddress(handle, "glEvalCoord1d"));
-    MapGrid2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLfloat , GLfloat , GLint , GLfloat , GLfloat )>(GetProcAddress(handle, "glMapGrid2f"));
-    MapGrid2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLdouble , GLdouble , GLint , GLdouble , GLdouble )>(GetProcAddress(handle, "glMapGrid2d"));
-    MapGrid1f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLfloat , GLfloat )>(GetProcAddress(handle, "glMapGrid1f"));
-    MapGrid1d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLdouble , GLdouble )>(GetProcAddress(handle, "glMapGrid1d"));
-    Map2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat , GLfloat , GLint , GLint , GLfloat , GLfloat , GLint , GLint , const GLfloat *)>(GetProcAddress(handle, "glMap2f"));
-    Map2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLdouble , GLdouble , GLint , GLint , GLdouble , GLdouble , GLint , GLint , const GLdouble *)>(GetProcAddress(handle, "glMap2d"));
-    Map1f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat , GLfloat , GLint , GLint , const GLfloat *)>(GetProcAddress(handle, "glMap1f"));
-    Map1d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLdouble , GLdouble , GLint , GLint , const GLdouble *)>(GetProcAddress(handle, "glMap1d"));
-    PushAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbitfield )>(GetProcAddress(handle, "glPushAttrib"));
-    PopAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(GetProcAddress(handle, "glPopAttrib"));
-    Accum = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat )>(GetProcAddress(handle, "glAccum"));
-    IndexMask = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(GetProcAddress(handle, "glIndexMask"));
-    ClearIndex = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(GetProcAddress(handle, "glClearIndex"));
-    ClearAccum = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(GetProcAddress(handle, "glClearAccum"));
-    PushName = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(GetProcAddress(handle, "glPushName"));
-    PopName = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(GetProcAddress(handle, "glPopName"));
-    PassThrough = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(GetProcAddress(handle, "glPassThrough"));
-    LoadName = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(GetProcAddress(handle, "glLoadName"));
-    InitNames = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(GetProcAddress(handle, "glInitNames"));
-    RenderMode = reinterpret_cast<GLint (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glRenderMode"));
-    SelectBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(GetProcAddress(handle, "glSelectBuffer"));
-    FeedbackBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLenum , GLfloat *)>(GetProcAddress(handle, "glFeedbackBuffer"));
-    TexGeniv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(GetProcAddress(handle, "glTexGeniv"));
-    TexGeni = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint )>(GetProcAddress(handle, "glTexGeni"));
-    TexGenfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLfloat *)>(GetProcAddress(handle, "glTexGenfv"));
-    TexGenf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat )>(GetProcAddress(handle, "glTexGenf"));
-    TexGendv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLdouble *)>(GetProcAddress(handle, "glTexGendv"));
-    TexGend = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLdouble )>(GetProcAddress(handle, "glTexGend"));
-    TexEnviv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(GetProcAddress(handle, "glTexEnviv"));
-    TexEnvi = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint )>(GetProcAddress(handle, "glTexEnvi"));
-    TexEnvfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLfloat *)>(GetProcAddress(handle, "glTexEnvfv"));
-    TexEnvf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat )>(GetProcAddress(handle, "glTexEnvf"));
-    ShadeModel = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glShadeModel"));
-    PolygonStipple = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLubyte *)>(GetProcAddress(handle, "glPolygonStipple"));
-    Materialiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(GetProcAddress(handle, "glMaterialiv"));
-    Materiali = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint )>(GetProcAddress(handle, "glMateriali"));
-    Materialfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLfloat *)>(GetProcAddress(handle, "glMaterialfv"));
-    Materialf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat )>(GetProcAddress(handle, "glMaterialf"));
-    LineStipple = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLushort )>(GetProcAddress(handle, "glLineStipple"));
-    LightModeliv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLint *)>(GetProcAddress(handle, "glLightModeliv"));
-    LightModeli = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(GetProcAddress(handle, "glLightModeli"));
-    LightModelfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLfloat *)>(GetProcAddress(handle, "glLightModelfv"));
-    LightModelf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat )>(GetProcAddress(handle, "glLightModelf"));
-    Lightiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(GetProcAddress(handle, "glLightiv"));
-    Lighti = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint )>(GetProcAddress(handle, "glLighti"));
-    Lightfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLfloat *)>(GetProcAddress(handle, "glLightfv"));
-    Lightf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat )>(GetProcAddress(handle, "glLightf"));
-    Fogiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLint *)>(GetProcAddress(handle, "glFogiv"));
-    Fogi = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(GetProcAddress(handle, "glFogi"));
-    Fogfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLfloat *)>(GetProcAddress(handle, "glFogfv"));
-    Fogf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat )>(GetProcAddress(handle, "glFogf"));
-    ColorMaterial = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum )>(GetProcAddress(handle, "glColorMaterial"));
-    ClipPlane = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLdouble *)>(GetProcAddress(handle, "glClipPlane"));
-    Vertex4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(GetProcAddress(handle, "glVertex4sv"));
-    Vertex4s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort , GLshort )>(GetProcAddress(handle, "glVertex4s"));
-    Vertex4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(GetProcAddress(handle, "glVertex4iv"));
-    Vertex4i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint , GLint )>(GetProcAddress(handle, "glVertex4i"));
-    Vertex4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glVertex4fv"));
-    Vertex4f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(GetProcAddress(handle, "glVertex4f"));
-    Vertex4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glVertex4dv"));
-    Vertex4d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble , GLdouble )>(GetProcAddress(handle, "glVertex4d"));
-    Vertex3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(GetProcAddress(handle, "glVertex3sv"));
-    Vertex3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort )>(GetProcAddress(handle, "glVertex3s"));
-    Vertex3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(GetProcAddress(handle, "glVertex3iv"));
-    Vertex3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint )>(GetProcAddress(handle, "glVertex3i"));
-    Vertex3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glVertex3fv"));
-    Vertex3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat )>(GetProcAddress(handle, "glVertex3f"));
-    Vertex3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glVertex3dv"));
-    Vertex3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble )>(GetProcAddress(handle, "glVertex3d"));
-    Vertex2sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(GetProcAddress(handle, "glVertex2sv"));
-    Vertex2s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort )>(GetProcAddress(handle, "glVertex2s"));
-    Vertex2iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(GetProcAddress(handle, "glVertex2iv"));
-    Vertex2i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint )>(GetProcAddress(handle, "glVertex2i"));
-    Vertex2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glVertex2fv"));
-    Vertex2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(GetProcAddress(handle, "glVertex2f"));
-    Vertex2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glVertex2dv"));
-    Vertex2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble )>(GetProcAddress(handle, "glVertex2d"));
-    TexCoord4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(GetProcAddress(handle, "glTexCoord4sv"));
-    TexCoord4s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort , GLshort )>(GetProcAddress(handle, "glTexCoord4s"));
-    TexCoord4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(GetProcAddress(handle, "glTexCoord4iv"));
-    TexCoord4i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint , GLint )>(GetProcAddress(handle, "glTexCoord4i"));
-    TexCoord4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glTexCoord4fv"));
-    TexCoord4f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(GetProcAddress(handle, "glTexCoord4f"));
-    TexCoord4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glTexCoord4dv"));
-    TexCoord4d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble , GLdouble )>(GetProcAddress(handle, "glTexCoord4d"));
-    TexCoord3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(GetProcAddress(handle, "glTexCoord3sv"));
-    TexCoord3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort )>(GetProcAddress(handle, "glTexCoord3s"));
-    TexCoord3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(GetProcAddress(handle, "glTexCoord3iv"));
-    TexCoord3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint )>(GetProcAddress(handle, "glTexCoord3i"));
-    TexCoord3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glTexCoord3fv"));
-    TexCoord3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat )>(GetProcAddress(handle, "glTexCoord3f"));
-    TexCoord3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glTexCoord3dv"));
-    TexCoord3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble )>(GetProcAddress(handle, "glTexCoord3d"));
-    TexCoord2sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(GetProcAddress(handle, "glTexCoord2sv"));
-    TexCoord2s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort )>(GetProcAddress(handle, "glTexCoord2s"));
-    TexCoord2iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(GetProcAddress(handle, "glTexCoord2iv"));
-    TexCoord2i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint )>(GetProcAddress(handle, "glTexCoord2i"));
-    TexCoord2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glTexCoord2fv"));
-    TexCoord2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(GetProcAddress(handle, "glTexCoord2f"));
-    TexCoord2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glTexCoord2dv"));
-    TexCoord2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble )>(GetProcAddress(handle, "glTexCoord2d"));
-    TexCoord1sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(GetProcAddress(handle, "glTexCoord1sv"));
-    TexCoord1s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort )>(GetProcAddress(handle, "glTexCoord1s"));
-    TexCoord1iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(GetProcAddress(handle, "glTexCoord1iv"));
-    TexCoord1i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint )>(GetProcAddress(handle, "glTexCoord1i"));
-    TexCoord1fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glTexCoord1fv"));
-    TexCoord1f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(GetProcAddress(handle, "glTexCoord1f"));
-    TexCoord1dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glTexCoord1dv"));
-    TexCoord1d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble )>(GetProcAddress(handle, "glTexCoord1d"));
-    Rectsv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *, const GLshort *)>(GetProcAddress(handle, "glRectsv"));
-    Rects = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort , GLshort )>(GetProcAddress(handle, "glRects"));
-    Rectiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *, const GLint *)>(GetProcAddress(handle, "glRectiv"));
-    Recti = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint , GLint )>(GetProcAddress(handle, "glRecti"));
-    Rectfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *, const GLfloat *)>(GetProcAddress(handle, "glRectfv"));
-    Rectf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(GetProcAddress(handle, "glRectf"));
-    Rectdv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *, const GLdouble *)>(GetProcAddress(handle, "glRectdv"));
-    Rectd = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble , GLdouble )>(GetProcAddress(handle, "glRectd"));
-    RasterPos4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(GetProcAddress(handle, "glRasterPos4sv"));
-    RasterPos4s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort , GLshort )>(GetProcAddress(handle, "glRasterPos4s"));
-    RasterPos4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(GetProcAddress(handle, "glRasterPos4iv"));
-    RasterPos4i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint , GLint )>(GetProcAddress(handle, "glRasterPos4i"));
-    RasterPos4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glRasterPos4fv"));
-    RasterPos4f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(GetProcAddress(handle, "glRasterPos4f"));
-    RasterPos4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glRasterPos4dv"));
-    RasterPos4d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble , GLdouble )>(GetProcAddress(handle, "glRasterPos4d"));
-    RasterPos3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(GetProcAddress(handle, "glRasterPos3sv"));
-    RasterPos3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort )>(GetProcAddress(handle, "glRasterPos3s"));
-    RasterPos3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(GetProcAddress(handle, "glRasterPos3iv"));
-    RasterPos3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint )>(GetProcAddress(handle, "glRasterPos3i"));
-    RasterPos3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glRasterPos3fv"));
-    RasterPos3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat )>(GetProcAddress(handle, "glRasterPos3f"));
-    RasterPos3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glRasterPos3dv"));
-    RasterPos3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble )>(GetProcAddress(handle, "glRasterPos3d"));
-    RasterPos2sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(GetProcAddress(handle, "glRasterPos2sv"));
-    RasterPos2s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort )>(GetProcAddress(handle, "glRasterPos2s"));
-    RasterPos2iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(GetProcAddress(handle, "glRasterPos2iv"));
-    RasterPos2i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint )>(GetProcAddress(handle, "glRasterPos2i"));
-    RasterPos2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glRasterPos2fv"));
-    RasterPos2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(GetProcAddress(handle, "glRasterPos2f"));
-    RasterPos2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glRasterPos2dv"));
-    RasterPos2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble )>(GetProcAddress(handle, "glRasterPos2d"));
-    Normal3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(GetProcAddress(handle, "glNormal3sv"));
-    Normal3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort )>(GetProcAddress(handle, "glNormal3s"));
-    Normal3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(GetProcAddress(handle, "glNormal3iv"));
-    Normal3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint )>(GetProcAddress(handle, "glNormal3i"));
-    Normal3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glNormal3fv"));
-    Normal3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat )>(GetProcAddress(handle, "glNormal3f"));
-    Normal3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glNormal3dv"));
-    Normal3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble )>(GetProcAddress(handle, "glNormal3d"));
-    Normal3bv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLbyte *)>(GetProcAddress(handle, "glNormal3bv"));
-    Normal3b = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbyte , GLbyte , GLbyte )>(GetProcAddress(handle, "glNormal3b"));
-    Indexsv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(GetProcAddress(handle, "glIndexsv"));
-    Indexs = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort )>(GetProcAddress(handle, "glIndexs"));
-    Indexiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(GetProcAddress(handle, "glIndexiv"));
-    Indexi = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint )>(GetProcAddress(handle, "glIndexi"));
-    Indexfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glIndexfv"));
-    Indexf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(GetProcAddress(handle, "glIndexf"));
-    Indexdv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glIndexdv"));
-    Indexd = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble )>(GetProcAddress(handle, "glIndexd"));
-    End = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(GetProcAddress(handle, "glEnd"));
-    EdgeFlagv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLboolean *)>(GetProcAddress(handle, "glEdgeFlagv"));
-    EdgeFlag = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLboolean )>(GetProcAddress(handle, "glEdgeFlag"));
-    Color4usv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLushort *)>(GetProcAddress(handle, "glColor4usv"));
-    Color4us = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLushort , GLushort , GLushort , GLushort )>(GetProcAddress(handle, "glColor4us"));
-    Color4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLuint *)>(GetProcAddress(handle, "glColor4uiv"));
-    Color4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint , GLuint )>(GetProcAddress(handle, "glColor4ui"));
-    Color4ubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLubyte *)>(GetProcAddress(handle, "glColor4ubv"));
-    Color4ub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLubyte , GLubyte , GLubyte , GLubyte )>(GetProcAddress(handle, "glColor4ub"));
-    Color4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(GetProcAddress(handle, "glColor4sv"));
-    Color4s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort , GLshort )>(GetProcAddress(handle, "glColor4s"));
-    Color4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(GetProcAddress(handle, "glColor4iv"));
-    Color4i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint , GLint )>(GetProcAddress(handle, "glColor4i"));
-    Color4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glColor4fv"));
-    Color4f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(GetProcAddress(handle, "glColor4f"));
-    Color4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glColor4dv"));
-    Color4d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble , GLdouble )>(GetProcAddress(handle, "glColor4d"));
-    Color4bv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLbyte *)>(GetProcAddress(handle, "glColor4bv"));
-    Color4b = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbyte , GLbyte , GLbyte , GLbyte )>(GetProcAddress(handle, "glColor4b"));
-    Color3usv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLushort *)>(GetProcAddress(handle, "glColor3usv"));
-    Color3us = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLushort , GLushort , GLushort )>(GetProcAddress(handle, "glColor3us"));
-    Color3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLuint *)>(GetProcAddress(handle, "glColor3uiv"));
-    Color3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint )>(GetProcAddress(handle, "glColor3ui"));
-    Color3ubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLubyte *)>(GetProcAddress(handle, "glColor3ubv"));
-    Color3ub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLubyte , GLubyte , GLubyte )>(GetProcAddress(handle, "glColor3ub"));
-    Color3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(GetProcAddress(handle, "glColor3sv"));
-    Color3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort )>(GetProcAddress(handle, "glColor3s"));
-    Color3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(GetProcAddress(handle, "glColor3iv"));
-    Color3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint )>(GetProcAddress(handle, "glColor3i"));
-    Color3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(GetProcAddress(handle, "glColor3fv"));
-    Color3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat )>(GetProcAddress(handle, "glColor3f"));
-    Color3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(GetProcAddress(handle, "glColor3dv"));
-    Color3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble )>(GetProcAddress(handle, "glColor3d"));
-    Color3bv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLbyte *)>(GetProcAddress(handle, "glColor3bv"));
-    Color3b = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbyte , GLbyte , GLbyte )>(GetProcAddress(handle, "glColor3b"));
-    Bitmap = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLsizei , GLfloat , GLfloat , GLfloat , GLfloat , const GLubyte *)>(GetProcAddress(handle, "glBitmap"));
-    Begin = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glBegin"));
-    ListBase = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(GetProcAddress(handle, "glListBase"));
-    GenLists = reinterpret_cast<GLuint (QOPENGLF_APIENTRYP)(GLsizei )>(GetProcAddress(handle, "glGenLists"));
-    DeleteLists = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei )>(GetProcAddress(handle, "glDeleteLists"));
-    CallLists = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLenum , const GLvoid *)>(GetProcAddress(handle, "glCallLists"));
-    CallList = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(GetProcAddress(handle, "glCallList"));
-    EndList = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(GetProcAddress(handle, "glEndList"));
-    NewList = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(GetProcAddress(handle, "glNewList"));
-#else
-    Translatef = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glTranslatef"));
-    Translated = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glTranslated"));
-    Scalef = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glScalef"));
-    Scaled = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glScaled"));
-    Rotatef = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glRotatef"));
-    Rotated = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glRotated"));
-    PushMatrix = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glPushMatrix"));
-    PopMatrix = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glPopMatrix"));
-    Ortho = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glOrtho"));
-    MultMatrixd = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glMultMatrixd"));
-    MultMatrixf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glMultMatrixf"));
-    MatrixMode = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glMatrixMode"));
-    LoadMatrixd = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glLoadMatrixd"));
-    LoadMatrixf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glLoadMatrixf"));
-    LoadIdentity = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glLoadIdentity"));
-    Frustum = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glFrustum"));
-    IsList = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glIsList"));
-    GetTexGeniv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress("glGetTexGeniv"));
-    GetTexGenfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(context->getProcAddress("glGetTexGenfv"));
-    GetTexGendv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLdouble *)>(context->getProcAddress("glGetTexGendv"));
-    GetTexEnviv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress("glGetTexEnviv"));
-    GetTexEnvfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(context->getProcAddress("glGetTexEnvfv"));
-    GetPolygonStipple = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLubyte *)>(context->getProcAddress("glGetPolygonStipple"));
-    GetPixelMapusv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLushort *)>(context->getProcAddress("glGetPixelMapusv"));
-    GetPixelMapuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint *)>(context->getProcAddress("glGetPixelMapuiv"));
-    GetPixelMapfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat *)>(context->getProcAddress("glGetPixelMapfv"));
-    GetMaterialiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress("glGetMaterialiv"));
-    GetMaterialfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(context->getProcAddress("glGetMaterialfv"));
-    GetMapiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress("glGetMapiv"));
-    GetMapfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(context->getProcAddress("glGetMapfv"));
-    GetMapdv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLdouble *)>(context->getProcAddress("glGetMapdv"));
-    GetLightiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress("glGetLightiv"));
-    GetLightfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(context->getProcAddress("glGetLightfv"));
-    GetClipPlane = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLdouble *)>(context->getProcAddress("glGetClipPlane"));
-    DrawPixels = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glDrawPixels"));
-    CopyPixels = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLsizei , GLsizei , GLenum )>(context->getProcAddress("glCopyPixels"));
-    PixelMapusv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLushort *)>(context->getProcAddress("glPixelMapusv"));
-    PixelMapuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLuint *)>(context->getProcAddress("glPixelMapuiv"));
-    PixelMapfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLfloat *)>(context->getProcAddress("glPixelMapfv"));
-    PixelTransferi = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(context->getProcAddress("glPixelTransferi"));
-    PixelTransferf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat )>(context->getProcAddress("glPixelTransferf"));
-    PixelZoom = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(context->getProcAddress("glPixelZoom"));
-    AlphaFunc = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat )>(context->getProcAddress("glAlphaFunc"));
-    EvalPoint2 = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint )>(context->getProcAddress("glEvalPoint2"));
-    EvalMesh2 = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint )>(context->getProcAddress("glEvalMesh2"));
-    EvalPoint1 = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint )>(context->getProcAddress("glEvalPoint1"));
-    EvalMesh1 = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint )>(context->getProcAddress("glEvalMesh1"));
-    EvalCoord2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glEvalCoord2fv"));
-    EvalCoord2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(context->getProcAddress("glEvalCoord2f"));
-    EvalCoord2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glEvalCoord2dv"));
-    EvalCoord2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble )>(context->getProcAddress("glEvalCoord2d"));
-    EvalCoord1fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glEvalCoord1fv"));
-    EvalCoord1f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(context->getProcAddress("glEvalCoord1f"));
-    EvalCoord1dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glEvalCoord1dv"));
-    EvalCoord1d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble )>(context->getProcAddress("glEvalCoord1d"));
-    MapGrid2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLfloat , GLfloat , GLint , GLfloat , GLfloat )>(context->getProcAddress("glMapGrid2f"));
-    MapGrid2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLdouble , GLdouble , GLint , GLdouble , GLdouble )>(context->getProcAddress("glMapGrid2d"));
-    MapGrid1f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLfloat , GLfloat )>(context->getProcAddress("glMapGrid1f"));
-    MapGrid1d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLdouble , GLdouble )>(context->getProcAddress("glMapGrid1d"));
-    Map2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat , GLfloat , GLint , GLint , GLfloat , GLfloat , GLint , GLint , const GLfloat *)>(context->getProcAddress("glMap2f"));
-    Map2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLdouble , GLdouble , GLint , GLint , GLdouble , GLdouble , GLint , GLint , const GLdouble *)>(context->getProcAddress("glMap2d"));
-    Map1f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat , GLfloat , GLint , GLint , const GLfloat *)>(context->getProcAddress("glMap1f"));
-    Map1d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLdouble , GLdouble , GLint , GLint , const GLdouble *)>(context->getProcAddress("glMap1d"));
-    PushAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbitfield )>(context->getProcAddress("glPushAttrib"));
-    PopAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glPopAttrib"));
-    Accum = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat )>(context->getProcAddress("glAccum"));
-    IndexMask = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glIndexMask"));
-    ClearIndex = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(context->getProcAddress("glClearIndex"));
-    ClearAccum = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glClearAccum"));
-    PushName = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glPushName"));
-    PopName = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glPopName"));
-    PassThrough = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(context->getProcAddress("glPassThrough"));
-    LoadName = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glLoadName"));
-    InitNames = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glInitNames"));
-    RenderMode = reinterpret_cast<GLint (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glRenderMode"));
-    SelectBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLuint *)>(context->getProcAddress("glSelectBuffer"));
-    FeedbackBuffer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLenum , GLfloat *)>(context->getProcAddress("glFeedbackBuffer"));
-    TexGeniv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(context->getProcAddress("glTexGeniv"));
-    TexGeni = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint )>(context->getProcAddress("glTexGeni"));
-    TexGenfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLfloat *)>(context->getProcAddress("glTexGenfv"));
-    TexGenf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat )>(context->getProcAddress("glTexGenf"));
-    TexGendv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLdouble *)>(context->getProcAddress("glTexGendv"));
-    TexGend = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLdouble )>(context->getProcAddress("glTexGend"));
-    TexEnviv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(context->getProcAddress("glTexEnviv"));
-    TexEnvi = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint )>(context->getProcAddress("glTexEnvi"));
-    TexEnvfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLfloat *)>(context->getProcAddress("glTexEnvfv"));
-    TexEnvf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat )>(context->getProcAddress("glTexEnvf"));
-    ShadeModel = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glShadeModel"));
-    PolygonStipple = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLubyte *)>(context->getProcAddress("glPolygonStipple"));
-    Materialiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(context->getProcAddress("glMaterialiv"));
-    Materiali = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint )>(context->getProcAddress("glMateriali"));
-    Materialfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLfloat *)>(context->getProcAddress("glMaterialfv"));
-    Materialf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat )>(context->getProcAddress("glMaterialf"));
-    LineStipple = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLushort )>(context->getProcAddress("glLineStipple"));
-    LightModeliv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLint *)>(context->getProcAddress("glLightModeliv"));
-    LightModeli = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(context->getProcAddress("glLightModeli"));
-    LightModelfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLfloat *)>(context->getProcAddress("glLightModelfv"));
-    LightModelf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat )>(context->getProcAddress("glLightModelf"));
-    Lightiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(context->getProcAddress("glLightiv"));
-    Lighti = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint )>(context->getProcAddress("glLighti"));
-    Lightfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLfloat *)>(context->getProcAddress("glLightfv"));
-    Lightf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat )>(context->getProcAddress("glLightf"));
-    Fogiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLint *)>(context->getProcAddress("glFogiv"));
-    Fogi = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(context->getProcAddress("glFogi"));
-    Fogfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLfloat *)>(context->getProcAddress("glFogfv"));
-    Fogf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat )>(context->getProcAddress("glFogf"));
-    ColorMaterial = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum )>(context->getProcAddress("glColorMaterial"));
-    ClipPlane = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLdouble *)>(context->getProcAddress("glClipPlane"));
-    Vertex4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glVertex4sv"));
-    Vertex4s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort , GLshort )>(context->getProcAddress("glVertex4s"));
-    Vertex4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glVertex4iv"));
-    Vertex4i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint , GLint )>(context->getProcAddress("glVertex4i"));
-    Vertex4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glVertex4fv"));
-    Vertex4f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glVertex4f"));
-    Vertex4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glVertex4dv"));
-    Vertex4d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glVertex4d"));
-    Vertex3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glVertex3sv"));
-    Vertex3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort )>(context->getProcAddress("glVertex3s"));
-    Vertex3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glVertex3iv"));
-    Vertex3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint )>(context->getProcAddress("glVertex3i"));
-    Vertex3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glVertex3fv"));
-    Vertex3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glVertex3f"));
-    Vertex3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glVertex3dv"));
-    Vertex3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glVertex3d"));
-    Vertex2sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glVertex2sv"));
-    Vertex2s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort )>(context->getProcAddress("glVertex2s"));
-    Vertex2iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glVertex2iv"));
-    Vertex2i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint )>(context->getProcAddress("glVertex2i"));
-    Vertex2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glVertex2fv"));
-    Vertex2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(context->getProcAddress("glVertex2f"));
-    Vertex2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glVertex2dv"));
-    Vertex2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble )>(context->getProcAddress("glVertex2d"));
-    TexCoord4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glTexCoord4sv"));
-    TexCoord4s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort , GLshort )>(context->getProcAddress("glTexCoord4s"));
-    TexCoord4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glTexCoord4iv"));
-    TexCoord4i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint , GLint )>(context->getProcAddress("glTexCoord4i"));
-    TexCoord4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glTexCoord4fv"));
-    TexCoord4f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glTexCoord4f"));
-    TexCoord4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glTexCoord4dv"));
-    TexCoord4d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glTexCoord4d"));
-    TexCoord3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glTexCoord3sv"));
-    TexCoord3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort )>(context->getProcAddress("glTexCoord3s"));
-    TexCoord3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glTexCoord3iv"));
-    TexCoord3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint )>(context->getProcAddress("glTexCoord3i"));
-    TexCoord3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glTexCoord3fv"));
-    TexCoord3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glTexCoord3f"));
-    TexCoord3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glTexCoord3dv"));
-    TexCoord3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glTexCoord3d"));
-    TexCoord2sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glTexCoord2sv"));
-    TexCoord2s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort )>(context->getProcAddress("glTexCoord2s"));
-    TexCoord2iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glTexCoord2iv"));
-    TexCoord2i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint )>(context->getProcAddress("glTexCoord2i"));
-    TexCoord2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glTexCoord2fv"));
-    TexCoord2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(context->getProcAddress("glTexCoord2f"));
-    TexCoord2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glTexCoord2dv"));
-    TexCoord2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble )>(context->getProcAddress("glTexCoord2d"));
-    TexCoord1sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glTexCoord1sv"));
-    TexCoord1s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort )>(context->getProcAddress("glTexCoord1s"));
-    TexCoord1iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glTexCoord1iv"));
-    TexCoord1i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint )>(context->getProcAddress("glTexCoord1i"));
-    TexCoord1fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glTexCoord1fv"));
-    TexCoord1f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(context->getProcAddress("glTexCoord1f"));
-    TexCoord1dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glTexCoord1dv"));
-    TexCoord1d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble )>(context->getProcAddress("glTexCoord1d"));
-    Rectsv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *, const GLshort *)>(context->getProcAddress("glRectsv"));
-    Rects = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort , GLshort )>(context->getProcAddress("glRects"));
-    Rectiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *, const GLint *)>(context->getProcAddress("glRectiv"));
-    Recti = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint , GLint )>(context->getProcAddress("glRecti"));
-    Rectfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *, const GLfloat *)>(context->getProcAddress("glRectfv"));
-    Rectf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glRectf"));
-    Rectdv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *, const GLdouble *)>(context->getProcAddress("glRectdv"));
-    Rectd = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glRectd"));
-    RasterPos4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glRasterPos4sv"));
-    RasterPos4s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort , GLshort )>(context->getProcAddress("glRasterPos4s"));
-    RasterPos4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glRasterPos4iv"));
-    RasterPos4i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint , GLint )>(context->getProcAddress("glRasterPos4i"));
-    RasterPos4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glRasterPos4fv"));
-    RasterPos4f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glRasterPos4f"));
-    RasterPos4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glRasterPos4dv"));
-    RasterPos4d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glRasterPos4d"));
-    RasterPos3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glRasterPos3sv"));
-    RasterPos3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort )>(context->getProcAddress("glRasterPos3s"));
-    RasterPos3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glRasterPos3iv"));
-    RasterPos3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint )>(context->getProcAddress("glRasterPos3i"));
-    RasterPos3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glRasterPos3fv"));
-    RasterPos3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glRasterPos3f"));
-    RasterPos3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glRasterPos3dv"));
-    RasterPos3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glRasterPos3d"));
-    RasterPos2sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glRasterPos2sv"));
-    RasterPos2s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort )>(context->getProcAddress("glRasterPos2s"));
-    RasterPos2iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glRasterPos2iv"));
-    RasterPos2i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint )>(context->getProcAddress("glRasterPos2i"));
-    RasterPos2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glRasterPos2fv"));
-    RasterPos2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(context->getProcAddress("glRasterPos2f"));
-    RasterPos2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glRasterPos2dv"));
-    RasterPos2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble )>(context->getProcAddress("glRasterPos2d"));
-    Normal3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glNormal3sv"));
-    Normal3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort )>(context->getProcAddress("glNormal3s"));
-    Normal3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glNormal3iv"));
-    Normal3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint )>(context->getProcAddress("glNormal3i"));
-    Normal3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glNormal3fv"));
-    Normal3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glNormal3f"));
-    Normal3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glNormal3dv"));
-    Normal3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glNormal3d"));
-    Normal3bv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLbyte *)>(context->getProcAddress("glNormal3bv"));
-    Normal3b = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbyte , GLbyte , GLbyte )>(context->getProcAddress("glNormal3b"));
-    Indexsv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glIndexsv"));
-    Indexs = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort )>(context->getProcAddress("glIndexs"));
-    Indexiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glIndexiv"));
-    Indexi = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint )>(context->getProcAddress("glIndexi"));
-    Indexfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glIndexfv"));
-    Indexf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(context->getProcAddress("glIndexf"));
-    Indexdv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glIndexdv"));
-    Indexd = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble )>(context->getProcAddress("glIndexd"));
-    End = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glEnd"));
-    EdgeFlagv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLboolean *)>(context->getProcAddress("glEdgeFlagv"));
-    EdgeFlag = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLboolean )>(context->getProcAddress("glEdgeFlag"));
-    Color4usv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLushort *)>(context->getProcAddress("glColor4usv"));
-    Color4us = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLushort , GLushort , GLushort , GLushort )>(context->getProcAddress("glColor4us"));
-    Color4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLuint *)>(context->getProcAddress("glColor4uiv"));
-    Color4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint , GLuint )>(context->getProcAddress("glColor4ui"));
-    Color4ubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLubyte *)>(context->getProcAddress("glColor4ubv"));
-    Color4ub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLubyte , GLubyte , GLubyte , GLubyte )>(context->getProcAddress("glColor4ub"));
-    Color4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glColor4sv"));
-    Color4s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort , GLshort )>(context->getProcAddress("glColor4s"));
-    Color4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glColor4iv"));
-    Color4i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint , GLint )>(context->getProcAddress("glColor4i"));
-    Color4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glColor4fv"));
-    Color4f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glColor4f"));
-    Color4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glColor4dv"));
-    Color4d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glColor4d"));
-    Color4bv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLbyte *)>(context->getProcAddress("glColor4bv"));
-    Color4b = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbyte , GLbyte , GLbyte , GLbyte )>(context->getProcAddress("glColor4b"));
-    Color3usv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLushort *)>(context->getProcAddress("glColor3usv"));
-    Color3us = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLushort , GLushort , GLushort )>(context->getProcAddress("glColor3us"));
-    Color3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLuint *)>(context->getProcAddress("glColor3uiv"));
-    Color3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint )>(context->getProcAddress("glColor3ui"));
-    Color3ubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLubyte *)>(context->getProcAddress("glColor3ubv"));
-    Color3ub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLubyte , GLubyte , GLubyte )>(context->getProcAddress("glColor3ub"));
-    Color3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glColor3sv"));
-    Color3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort )>(context->getProcAddress("glColor3s"));
-    Color3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glColor3iv"));
-    Color3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint )>(context->getProcAddress("glColor3i"));
-    Color3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glColor3fv"));
-    Color3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glColor3f"));
-    Color3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glColor3dv"));
-    Color3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glColor3d"));
-    Color3bv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLbyte *)>(context->getProcAddress("glColor3bv"));
-    Color3b = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbyte , GLbyte , GLbyte )>(context->getProcAddress("glColor3b"));
-    Bitmap = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLsizei , GLfloat , GLfloat , GLfloat , GLfloat , const GLubyte *)>(context->getProcAddress("glBitmap"));
-    Begin = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glBegin"));
-    ListBase = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glListBase"));
-    GenLists = reinterpret_cast<GLuint (QOPENGLF_APIENTRYP)(GLsizei )>(context->getProcAddress("glGenLists"));
-    DeleteLists = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLsizei )>(context->getProcAddress("glDeleteLists"));
-    CallLists = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLenum , const GLvoid *)>(context->getProcAddress("glCallLists"));
-    CallList = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint )>(context->getProcAddress("glCallList"));
-    EndList = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glEndList"));
-    NewList = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLenum )>(context->getProcAddress("glNewList"));
-#endif
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_1_0_DeprecatedBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(1, 0, QOpenGLVersionStatus::DeprecatedStatus);
-}
-
-QOpenGLFunctions_1_1_DeprecatedBackend::QOpenGLFunctions_1_1_DeprecatedBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 1.1 deprecated functions
-#if defined(Q_OS_WIN)
-    HMODULE handle = static_cast<HMODULE>(QOpenGLContext::openGLModuleHandle());
-    if (!handle)
-        handle = GetModuleHandleA("opengl32.dll");
-    PushClientAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbitfield )>(GetProcAddress(handle, "glPushClientAttrib"));
-    PopClientAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(GetProcAddress(handle, "glPopClientAttrib"));
-    Indexubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLubyte *)>(GetProcAddress(handle, "glIndexubv"));
-    Indexub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLubyte )>(GetProcAddress(handle, "glIndexub"));
-    PrioritizeTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *, const GLfloat *)>(GetProcAddress(handle, "glPrioritizeTextures"));
-    AreTexturesResident = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *, GLboolean *)>(GetProcAddress(handle, "glAreTexturesResident"));
-    VertexPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLenum , GLsizei , const GLvoid *)>(GetProcAddress(handle, "glVertexPointer"));
-    TexCoordPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLenum , GLsizei , const GLvoid *)>(GetProcAddress(handle, "glTexCoordPointer"));
-    NormalPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLvoid *)>(GetProcAddress(handle, "glNormalPointer"));
-    InterleavedArrays = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLvoid *)>(GetProcAddress(handle, "glInterleavedArrays"));
-    GetPointerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLvoid * *)>(GetProcAddress(handle, "glGetPointerv"));
-    IndexPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLvoid *)>(GetProcAddress(handle, "glIndexPointer"));
-    EnableClientState = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glEnableClientState"));
-    EdgeFlagPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLvoid *)>(GetProcAddress(handle, "glEdgeFlagPointer"));
-    DisableClientState = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(GetProcAddress(handle, "glDisableClientState"));
-    ColorPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLenum , GLsizei , const GLvoid *)>(GetProcAddress(handle, "glColorPointer"));
-    ArrayElement = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint )>(GetProcAddress(handle, "glArrayElement"));
-#else
-    PushClientAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbitfield )>(context->getProcAddress("glPushClientAttrib"));
-    PopClientAttrib = reinterpret_cast<void (QOPENGLF_APIENTRYP)()>(context->getProcAddress("glPopClientAttrib"));
-    Indexubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLubyte *)>(context->getProcAddress("glIndexubv"));
-    Indexub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLubyte )>(context->getProcAddress("glIndexub"));
-    PrioritizeTextures = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *, const GLfloat *)>(context->getProcAddress("glPrioritizeTextures"));
-    AreTexturesResident = reinterpret_cast<GLboolean (QOPENGLF_APIENTRYP)(GLsizei , const GLuint *, GLboolean *)>(context->getProcAddress("glAreTexturesResident"));
-    VertexPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glVertexPointer"));
-    TexCoordPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glTexCoordPointer"));
-    NormalPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glNormalPointer"));
-    InterleavedArrays = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glInterleavedArrays"));
-    GetPointerv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLvoid * *)>(context->getProcAddress("glGetPointerv"));
-    IndexPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glIndexPointer"));
-    EnableClientState = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glEnableClientState"));
-    EdgeFlagPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , const GLvoid *)>(context->getProcAddress("glEdgeFlagPointer"));
-    DisableClientState = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glDisableClientState"));
-    ColorPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glColorPointer"));
-    ArrayElement = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint )>(context->getProcAddress("glArrayElement"));
-#endif
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_1_1_DeprecatedBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(1, 1, QOpenGLVersionStatus::DeprecatedStatus);
-}
-
-QOpenGLFunctions_1_2_DeprecatedBackend::QOpenGLFunctions_1_2_DeprecatedBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 1.2 deprecated functions
-    ResetMinmax = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glResetMinmax"));
-    ResetHistogram = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glResetHistogram"));
-    Minmax = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLboolean )>(context->getProcAddress("glMinmax"));
-    Histogram = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLenum , GLboolean )>(context->getProcAddress("glHistogram"));
-    GetMinmaxParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress("glGetMinmaxParameteriv"));
-    GetMinmaxParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(context->getProcAddress("glGetMinmaxParameterfv"));
-    GetMinmax = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLboolean , GLenum , GLenum , GLvoid *)>(context->getProcAddress("glGetMinmax"));
-    GetHistogramParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress("glGetHistogramParameteriv"));
-    GetHistogramParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(context->getProcAddress("glGetHistogramParameterfv"));
-    GetHistogram = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLboolean , GLenum , GLenum , GLvoid *)>(context->getProcAddress("glGetHistogram"));
-    SeparableFilter2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *, const GLvoid *)>(context->getProcAddress("glSeparableFilter2D"));
-    GetSeparableFilter = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLvoid *, GLvoid *, GLvoid *)>(context->getProcAddress("glGetSeparableFilter"));
-    GetConvolutionParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress("glGetConvolutionParameteriv"));
-    GetConvolutionParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(context->getProcAddress("glGetConvolutionParameterfv"));
-    GetConvolutionFilter = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLvoid *)>(context->getProcAddress("glGetConvolutionFilter"));
-    CopyConvolutionFilter2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint , GLint , GLsizei , GLsizei )>(context->getProcAddress("glCopyConvolutionFilter2D"));
-    CopyConvolutionFilter1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint , GLint , GLsizei )>(context->getProcAddress("glCopyConvolutionFilter1D"));
-    ConvolutionParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(context->getProcAddress("glConvolutionParameteriv"));
-    ConvolutionParameteri = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint )>(context->getProcAddress("glConvolutionParameteri"));
-    ConvolutionParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLfloat *)>(context->getProcAddress("glConvolutionParameterfv"));
-    ConvolutionParameterf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat )>(context->getProcAddress("glConvolutionParameterf"));
-    ConvolutionFilter2D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glConvolutionFilter2D"));
-    ConvolutionFilter1D = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glConvolutionFilter1D"));
-    CopyColorSubTable = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLint , GLint , GLsizei )>(context->getProcAddress("glCopyColorSubTable"));
-    ColorSubTable = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glColorSubTable"));
-    GetColorTableParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint *)>(context->getProcAddress("glGetColorTableParameteriv"));
-    GetColorTableParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLfloat *)>(context->getProcAddress("glGetColorTableParameterfv"));
-    GetColorTable = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLvoid *)>(context->getProcAddress("glGetColorTable"));
-    CopyColorTable = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLint , GLint , GLsizei )>(context->getProcAddress("glCopyColorTable"));
-    ColorTableParameteriv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLint *)>(context->getProcAddress("glColorTableParameteriv"));
-    ColorTableParameterfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLfloat *)>(context->getProcAddress("glColorTableParameterfv"));
-    ColorTable = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLsizei , GLenum , GLenum , const GLvoid *)>(context->getProcAddress("glColorTable"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_1_2_DeprecatedBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(1, 2, QOpenGLVersionStatus::DeprecatedStatus);
-}
-
-QOpenGLFunctions_1_3_DeprecatedBackend::QOpenGLFunctions_1_3_DeprecatedBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 1.3 deprecated functions
-    MultTransposeMatrixd = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glMultTransposeMatrixd"));
-    MultTransposeMatrixf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glMultTransposeMatrixf"));
-    LoadTransposeMatrixd = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glLoadTransposeMatrixd"));
-    LoadTransposeMatrixf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glLoadTransposeMatrixf"));
-    MultiTexCoord4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLshort *)>(context->getProcAddress("glMultiTexCoord4sv"));
-    MultiTexCoord4s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLshort , GLshort , GLshort , GLshort )>(context->getProcAddress("glMultiTexCoord4s"));
-    MultiTexCoord4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLint *)>(context->getProcAddress("glMultiTexCoord4iv"));
-    MultiTexCoord4i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint , GLint )>(context->getProcAddress("glMultiTexCoord4i"));
-    MultiTexCoord4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLfloat *)>(context->getProcAddress("glMultiTexCoord4fv"));
-    MultiTexCoord4f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glMultiTexCoord4f"));
-    MultiTexCoord4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLdouble *)>(context->getProcAddress("glMultiTexCoord4dv"));
-    MultiTexCoord4d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLdouble , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glMultiTexCoord4d"));
-    MultiTexCoord3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLshort *)>(context->getProcAddress("glMultiTexCoord3sv"));
-    MultiTexCoord3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLshort , GLshort , GLshort )>(context->getProcAddress("glMultiTexCoord3s"));
-    MultiTexCoord3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLint *)>(context->getProcAddress("glMultiTexCoord3iv"));
-    MultiTexCoord3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint , GLint )>(context->getProcAddress("glMultiTexCoord3i"));
-    MultiTexCoord3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLfloat *)>(context->getProcAddress("glMultiTexCoord3fv"));
-    MultiTexCoord3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glMultiTexCoord3f"));
-    MultiTexCoord3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLdouble *)>(context->getProcAddress("glMultiTexCoord3dv"));
-    MultiTexCoord3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glMultiTexCoord3d"));
-    MultiTexCoord2sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLshort *)>(context->getProcAddress("glMultiTexCoord2sv"));
-    MultiTexCoord2s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLshort , GLshort )>(context->getProcAddress("glMultiTexCoord2s"));
-    MultiTexCoord2iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLint *)>(context->getProcAddress("glMultiTexCoord2iv"));
-    MultiTexCoord2i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint , GLint )>(context->getProcAddress("glMultiTexCoord2i"));
-    MultiTexCoord2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLfloat *)>(context->getProcAddress("glMultiTexCoord2fv"));
-    MultiTexCoord2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat , GLfloat )>(context->getProcAddress("glMultiTexCoord2f"));
-    MultiTexCoord2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLdouble *)>(context->getProcAddress("glMultiTexCoord2dv"));
-    MultiTexCoord2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLdouble , GLdouble )>(context->getProcAddress("glMultiTexCoord2d"));
-    MultiTexCoord1sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLshort *)>(context->getProcAddress("glMultiTexCoord1sv"));
-    MultiTexCoord1s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLshort )>(context->getProcAddress("glMultiTexCoord1s"));
-    MultiTexCoord1iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLint *)>(context->getProcAddress("glMultiTexCoord1iv"));
-    MultiTexCoord1i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLint )>(context->getProcAddress("glMultiTexCoord1i"));
-    MultiTexCoord1fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLfloat *)>(context->getProcAddress("glMultiTexCoord1fv"));
-    MultiTexCoord1f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLfloat )>(context->getProcAddress("glMultiTexCoord1f"));
-    MultiTexCoord1dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLdouble *)>(context->getProcAddress("glMultiTexCoord1dv"));
-    MultiTexCoord1d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLdouble )>(context->getProcAddress("glMultiTexCoord1d"));
-    ClientActiveTexture = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum )>(context->getProcAddress("glClientActiveTexture"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_1_3_DeprecatedBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(1, 3, QOpenGLVersionStatus::DeprecatedStatus);
-}
-
-QOpenGLFunctions_1_4_DeprecatedBackend::QOpenGLFunctions_1_4_DeprecatedBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 1.4 deprecated functions
-    WindowPos3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glWindowPos3sv"));
-    WindowPos3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort )>(context->getProcAddress("glWindowPos3s"));
-    WindowPos3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glWindowPos3iv"));
-    WindowPos3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint )>(context->getProcAddress("glWindowPos3i"));
-    WindowPos3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glWindowPos3fv"));
-    WindowPos3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glWindowPos3f"));
-    WindowPos3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glWindowPos3dv"));
-    WindowPos3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glWindowPos3d"));
-    WindowPos2sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glWindowPos2sv"));
-    WindowPos2s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort )>(context->getProcAddress("glWindowPos2s"));
-    WindowPos2iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glWindowPos2iv"));
-    WindowPos2i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint )>(context->getProcAddress("glWindowPos2i"));
-    WindowPos2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glWindowPos2fv"));
-    WindowPos2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat )>(context->getProcAddress("glWindowPos2f"));
-    WindowPos2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glWindowPos2dv"));
-    WindowPos2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble )>(context->getProcAddress("glWindowPos2d"));
-    SecondaryColorPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glSecondaryColorPointer"));
-    SecondaryColor3usv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLushort *)>(context->getProcAddress("glSecondaryColor3usv"));
-    SecondaryColor3us = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLushort , GLushort , GLushort )>(context->getProcAddress("glSecondaryColor3us"));
-    SecondaryColor3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLuint *)>(context->getProcAddress("glSecondaryColor3uiv"));
-    SecondaryColor3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint )>(context->getProcAddress("glSecondaryColor3ui"));
-    SecondaryColor3ubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLubyte *)>(context->getProcAddress("glSecondaryColor3ubv"));
-    SecondaryColor3ub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLubyte , GLubyte , GLubyte )>(context->getProcAddress("glSecondaryColor3ub"));
-    SecondaryColor3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLshort *)>(context->getProcAddress("glSecondaryColor3sv"));
-    SecondaryColor3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLshort , GLshort , GLshort )>(context->getProcAddress("glSecondaryColor3s"));
-    SecondaryColor3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLint *)>(context->getProcAddress("glSecondaryColor3iv"));
-    SecondaryColor3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLint , GLint , GLint )>(context->getProcAddress("glSecondaryColor3i"));
-    SecondaryColor3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glSecondaryColor3fv"));
-    SecondaryColor3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glSecondaryColor3f"));
-    SecondaryColor3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glSecondaryColor3dv"));
-    SecondaryColor3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glSecondaryColor3d"));
-    SecondaryColor3bv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLbyte *)>(context->getProcAddress("glSecondaryColor3bv"));
-    SecondaryColor3b = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLbyte , GLbyte , GLbyte )>(context->getProcAddress("glSecondaryColor3b"));
-    FogCoordPointer = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , const GLvoid *)>(context->getProcAddress("glFogCoordPointer"));
-    FogCoorddv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLdouble *)>(context->getProcAddress("glFogCoorddv"));
-    FogCoordd = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLdouble )>(context->getProcAddress("glFogCoordd"));
-    FogCoordfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(const GLfloat *)>(context->getProcAddress("glFogCoordfv"));
-    FogCoordf = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLfloat )>(context->getProcAddress("glFogCoordf"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_1_4_DeprecatedBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(1, 4, QOpenGLVersionStatus::DeprecatedStatus);
-}
-
-QOpenGLFunctions_2_0_DeprecatedBackend::QOpenGLFunctions_2_0_DeprecatedBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 2.0 deprecated functions
-    VertexAttrib4usv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLushort *)>(context->getProcAddress("glVertexAttrib4usv"));
-    VertexAttrib4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttrib4uiv"));
-    VertexAttrib4ubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLubyte *)>(context->getProcAddress("glVertexAttrib4ubv"));
-    VertexAttrib4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib4sv"));
-    VertexAttrib4s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLshort , GLshort , GLshort , GLshort )>(context->getProcAddress("glVertexAttrib4s"));
-    VertexAttrib4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttrib4iv"));
-    VertexAttrib4fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glVertexAttrib4fv"));
-    VertexAttrib4f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glVertexAttrib4f"));
-    VertexAttrib4dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttrib4dv"));
-    VertexAttrib4d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glVertexAttrib4d"));
-    VertexAttrib4bv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLbyte *)>(context->getProcAddress("glVertexAttrib4bv"));
-    VertexAttrib4Nusv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLushort *)>(context->getProcAddress("glVertexAttrib4Nusv"));
-    VertexAttrib4Nuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttrib4Nuiv"));
-    VertexAttrib4Nubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLubyte *)>(context->getProcAddress("glVertexAttrib4Nubv"));
-    VertexAttrib4Nub = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLubyte , GLubyte , GLubyte , GLubyte )>(context->getProcAddress("glVertexAttrib4Nub"));
-    VertexAttrib4Nsv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib4Nsv"));
-    VertexAttrib4Niv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttrib4Niv"));
-    VertexAttrib4Nbv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLbyte *)>(context->getProcAddress("glVertexAttrib4Nbv"));
-    VertexAttrib3sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib3sv"));
-    VertexAttrib3s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLshort , GLshort , GLshort )>(context->getProcAddress("glVertexAttrib3s"));
-    VertexAttrib3fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glVertexAttrib3fv"));
-    VertexAttrib3f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat , GLfloat , GLfloat )>(context->getProcAddress("glVertexAttrib3f"));
-    VertexAttrib3dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttrib3dv"));
-    VertexAttrib3d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble , GLdouble , GLdouble )>(context->getProcAddress("glVertexAttrib3d"));
-    VertexAttrib2sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib2sv"));
-    VertexAttrib2s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLshort , GLshort )>(context->getProcAddress("glVertexAttrib2s"));
-    VertexAttrib2fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glVertexAttrib2fv"));
-    VertexAttrib2f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat , GLfloat )>(context->getProcAddress("glVertexAttrib2f"));
-    VertexAttrib2dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttrib2dv"));
-    VertexAttrib2d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble , GLdouble )>(context->getProcAddress("glVertexAttrib2d"));
-    VertexAttrib1sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttrib1sv"));
-    VertexAttrib1s = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLshort )>(context->getProcAddress("glVertexAttrib1s"));
-    VertexAttrib1fv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLfloat *)>(context->getProcAddress("glVertexAttrib1fv"));
-    VertexAttrib1f = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLfloat )>(context->getProcAddress("glVertexAttrib1f"));
-    VertexAttrib1dv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLdouble *)>(context->getProcAddress("glVertexAttrib1dv"));
-    VertexAttrib1d = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLdouble )>(context->getProcAddress("glVertexAttrib1d"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_2_0_DeprecatedBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(2, 0, QOpenGLVersionStatus::DeprecatedStatus);
-}
-
-QOpenGLFunctions_3_0_DeprecatedBackend::QOpenGLFunctions_3_0_DeprecatedBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 3.0 deprecated functions
-    VertexAttribI4usv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLushort *)>(context->getProcAddress("glVertexAttribI4usv"));
-    VertexAttribI4ubv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLubyte *)>(context->getProcAddress("glVertexAttribI4ubv"));
-    VertexAttribI4sv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLshort *)>(context->getProcAddress("glVertexAttribI4sv"));
-    VertexAttribI4bv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLbyte *)>(context->getProcAddress("glVertexAttribI4bv"));
-    VertexAttribI4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttribI4uiv"));
-    VertexAttribI3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttribI3uiv"));
-    VertexAttribI2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttribI2uiv"));
-    VertexAttribI1uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLuint *)>(context->getProcAddress("glVertexAttribI1uiv"));
-    VertexAttribI4iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttribI4iv"));
-    VertexAttribI3iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttribI3iv"));
-    VertexAttribI2iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttribI2iv"));
-    VertexAttribI1iv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , const GLint *)>(context->getProcAddress("glVertexAttribI1iv"));
-    VertexAttribI4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint , GLuint , GLuint )>(context->getProcAddress("glVertexAttribI4ui"));
-    VertexAttribI3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint , GLuint )>(context->getProcAddress("glVertexAttribI3ui"));
-    VertexAttribI2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint , GLuint )>(context->getProcAddress("glVertexAttribI2ui"));
-    VertexAttribI1ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLuint )>(context->getProcAddress("glVertexAttribI1ui"));
-    VertexAttribI4i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint , GLint )>(context->getProcAddress("glVertexAttribI4i"));
-    VertexAttribI3i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint , GLint )>(context->getProcAddress("glVertexAttribI3i"));
-    VertexAttribI2i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint , GLint )>(context->getProcAddress("glVertexAttribI2i"));
-    VertexAttribI1i = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLuint , GLint )>(context->getProcAddress("glVertexAttribI1i"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_3_0_DeprecatedBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(3, 0, QOpenGLVersionStatus::DeprecatedStatus);
-}
-
-QOpenGLFunctions_3_3_DeprecatedBackend::QOpenGLFunctions_3_3_DeprecatedBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 3.3 deprecated functions
-    SecondaryColorP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glSecondaryColorP3uiv"));
-    SecondaryColorP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glSecondaryColorP3ui"));
-    ColorP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glColorP4uiv"));
-    ColorP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glColorP4ui"));
-    ColorP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glColorP3uiv"));
-    ColorP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glColorP3ui"));
-    NormalP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glNormalP3uiv"));
-    NormalP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glNormalP3ui"));
-    MultiTexCoordP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glMultiTexCoordP4uiv"));
-    MultiTexCoordP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glMultiTexCoordP4ui"));
-    MultiTexCoordP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glMultiTexCoordP3uiv"));
-    MultiTexCoordP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glMultiTexCoordP3ui"));
-    MultiTexCoordP2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glMultiTexCoordP2uiv"));
-    MultiTexCoordP2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glMultiTexCoordP2ui"));
-    MultiTexCoordP1uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , const GLuint *)>(context->getProcAddress("glMultiTexCoordP1uiv"));
-    MultiTexCoordP1ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLuint )>(context->getProcAddress("glMultiTexCoordP1ui"));
-    TexCoordP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glTexCoordP4uiv"));
-    TexCoordP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glTexCoordP4ui"));
-    TexCoordP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glTexCoordP3uiv"));
-    TexCoordP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glTexCoordP3ui"));
-    TexCoordP2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glTexCoordP2uiv"));
-    TexCoordP2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glTexCoordP2ui"));
-    TexCoordP1uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glTexCoordP1uiv"));
-    TexCoordP1ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glTexCoordP1ui"));
-    VertexP4uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glVertexP4uiv"));
-    VertexP4ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glVertexP4ui"));
-    VertexP3uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glVertexP3uiv"));
-    VertexP3ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glVertexP3ui"));
-    VertexP2uiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , const GLuint *)>(context->getProcAddress("glVertexP2uiv"));
-    VertexP2ui = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLuint )>(context->getProcAddress("glVertexP2ui"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_3_3_DeprecatedBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(3, 3, QOpenGLVersionStatus::DeprecatedStatus);
-}
-
-QOpenGLFunctions_4_5_DeprecatedBackend::QOpenGLFunctions_4_5_DeprecatedBackend(QOpenGLContext *context)
-    : QOpenGLVersionFunctionsBackend(context)
-{
-    // OpenGL 4.5 deprecated functions
-    GetnMinmax = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLboolean , GLenum , GLenum , GLsizei , void *)>(context->getProcAddress("glGetnMinmax"));
-    GetnHistogram = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLboolean , GLenum , GLenum , GLsizei , void *)>(context->getProcAddress("glGetnHistogram"));
-    GetnSeparableFilter = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLsizei , void *, GLsizei , void *, void *)>(context->getProcAddress("glGetnSeparableFilter"));
-    GetnConvolutionFilter = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLsizei , void *)>(context->getProcAddress("glGetnConvolutionFilter"));
-    GetnColorTable = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLenum , GLsizei , void *)>(context->getProcAddress("glGetnColorTable"));
-    GetnPolygonStipple = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLsizei , GLubyte *)>(context->getProcAddress("glGetnPolygonStipple"));
-    GetnPixelMapusv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLushort *)>(context->getProcAddress("glGetnPixelMapusv"));
-    GetnPixelMapuiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLuint *)>(context->getProcAddress("glGetnPixelMapuiv"));
-    GetnPixelMapfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLsizei , GLfloat *)>(context->getProcAddress("glGetnPixelMapfv"));
-    GetnMapiv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLsizei , GLint *)>(context->getProcAddress("glGetnMapiv"));
-    GetnMapfv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLsizei , GLfloat *)>(context->getProcAddress("glGetnMapfv"));
-    GetnMapdv = reinterpret_cast<void (QOPENGLF_APIENTRYP)(GLenum , GLenum , GLsizei , GLdouble *)>(context->getProcAddress("glGetnMapdv"));
-
-}
-
-QOpenGLVersionStatus QOpenGLFunctions_4_5_DeprecatedBackend::versionStatus()
-{
-    return QOpenGLVersionStatus(4, 5, QOpenGLVersionStatus::DeprecatedStatus);
-}
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_0_CoreBackend, QT_OPENGL_1_0_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_1_CoreBackend, QT_OPENGL_1_1_FUNCTIONS)
+
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_2_CoreBackend, QT_OPENGL_1_2_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_3_CoreBackend, QT_OPENGL_1_3_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_4_CoreBackend, QT_OPENGL_1_4_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_5_CoreBackend, QT_OPENGL_1_5_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_2_0_CoreBackend, QT_OPENGL_2_0_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_2_1_CoreBackend, QT_OPENGL_2_1_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_3_0_CoreBackend, QT_OPENGL_3_0_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_3_1_CoreBackend, QT_OPENGL_3_1_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_3_2_CoreBackend, QT_OPENGL_3_2_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_3_3_CoreBackend, QT_OPENGL_3_3_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_4_0_CoreBackend, QT_OPENGL_4_0_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_4_1_CoreBackend, QT_OPENGL_4_1_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_4_2_CoreBackend, QT_OPENGL_4_2_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_4_3_CoreBackend, QT_OPENGL_4_3_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_4_4_CoreBackend, QT_OPENGL_4_4_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_4_5_CoreBackend, QT_OPENGL_4_5_FUNCTIONS)
+
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_0_DeprecatedBackend, QT_OPENGL_1_0_DEPRECATED_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_1_DeprecatedBackend, QT_OPENGL_1_1_DEPRECATED_FUNCTIONS)
+
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_2_DeprecatedBackend, QT_OPENGL_1_2_DEPRECATED_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_3_DeprecatedBackend, QT_OPENGL_1_3_DEPRECATED_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_1_4_DeprecatedBackend, QT_OPENGL_1_4_DEPRECATED_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_2_0_DeprecatedBackend, QT_OPENGL_2_0_DEPRECATED_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_3_0_DeprecatedBackend, QT_OPENGL_3_0_DEPRECATED_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_3_3_DeprecatedBackend, QT_OPENGL_3_3_DEPRECATED_FUNCTIONS)
+QT_OPENGL_IMPLEMENT(QOpenGLFunctions_4_5_DeprecatedBackend, QT_OPENGL_4_5_DEPRECATED_FUNCTIONS)
 
 #else
 
diff --git a/src/gui/opengl/qopenglversionfunctions.h b/src/gui/opengl/qopenglversionfunctions.h
index 20b21b81034..7f991b19553 100644
--- a/src/gui/opengl/qopenglversionfunctions.h
+++ b/src/gui/opengl/qopenglversionfunctions.h
@@ -1,6 +1,7 @@
 /****************************************************************************
 **
 ** Copyright (C) 2013 Klaralvdalens Datakonsult AB (KDAB)
+** Copyright (C) 2016 The Qt Company Ltd.
 ** Contact: https://www.qt.io/licensing/
 **
 ** This file is part of the QtGui module of the Qt Toolkit.
@@ -112,9 +113,61 @@ Q_DECL_CONSTEXPR inline bool operator!=(const QOpenGLVersionStatus &lhs, const Q
     return !operator==(lhs, rhs);
 }
 
+#define QT_OPENGL_DECLARE_FUNCTIONS(ret, name, args) \
+    ret (QOPENGLF_APIENTRYP name)args;
+#define QT_OPENGL_COUNT_FUNCTIONS(ret, name, args) +1
+
+#define QT_OPENGL_DECLARE(FUNCTIONS) \
+public: \
+    struct Functions { \
+        FUNCTIONS(QT_OPENGL_DECLARE_FUNCTIONS) \
+    }; \
+    union { \
+        QFunctionPointer functions[FUNCTIONS(QT_OPENGL_COUNT_FUNCTIONS)]; \
+        Functions f; \
+    }; \
+private: \
+    void init()
+
 class QOpenGLVersionFunctionsBackend
 {
 public:
+#define QT_OPENGL_VERSIONS(F) \
+        F(1_0_Core) \
+        F(1_1_Core) \
+        F(1_2_Core) \
+        F(1_3_Core) \
+        F(1_4_Core) \
+        F(1_5_Core) \
+        F(2_0_Core) \
+        F(2_1_Core) \
+        F(3_0_Core) \
+        F(3_1_Core) \
+        F(3_2_Core) \
+        F(3_3_Core) \
+        F(4_0_Core) \
+        F(4_1_Core) \
+        F(4_2_Core) \
+        F(4_3_Core) \
+        F(4_4_Core) \
+        F(4_5_Core) \
+        F(1_0_Deprecated) \
+        F(1_1_Deprecated) \
+        F(1_2_Deprecated) \
+        F(1_3_Deprecated) \
+        F(1_4_Deprecated) \
+        F(2_0_Deprecated) \
+        F(3_0_Deprecated) \
+        F(3_3_Deprecated) \
+        F(4_5_Deprecated) \
+
+#define VERSION_ENUM(X) OpenGL_##X,
+    enum Version {
+        QT_OPENGL_VERSIONS(VERSION_ENUM)
+        OpenGLVersionBackendCount
+    };
+#undef VERSION_ENUM
+
     QOpenGLVersionFunctionsBackend(QOpenGLContext *ctx)
         : context(ctx)
     {}
@@ -123,6 +176,17 @@ public:
     QAtomicInt refs;
 };
 
+class QOpenGLVersionFunctionsStorage
+{
+public:
+    QOpenGLVersionFunctionsStorage();
+    ~QOpenGLVersionFunctionsStorage();
+
+    QOpenGLVersionFunctionsBackend *backend(QOpenGLContext *context, QOpenGLVersionFunctionsBackend::Version v);
+
+    QOpenGLVersionFunctionsBackend **backends;
+};
+
 class QAbstractOpenGLFunctions;
 
 class QAbstractOpenGLFunctionsPrivate
@@ -133,12 +197,7 @@ public:
           initialized(false)
     {}
 
-    static QOpenGLVersionFunctionsBackend *functionsBackend(QOpenGLContext *context,
-                                                            const QOpenGLVersionStatus &v);
-    static void insertFunctionsBackend(QOpenGLContext *context,
-                                       const QOpenGLVersionStatus &v,
-                                       QOpenGLVersionFunctionsBackend *backend);
-    static void removeFunctionsBackend(QOpenGLContext *context, const QOpenGLVersionStatus &v);
+    static QOpenGLVersionFunctionsBackend *functionsBackend(QOpenGLContext *context, QOpenGLVersionFunctionsBackend::Version v);
     static void insertExternalFunctions(QOpenGLContext *context, QAbstractOpenGLFunctions *f);
     static void removeExternalFunctions(QOpenGLContext *context, QAbstractOpenGLFunctions *f);
 
@@ -179,1456 +238,1648 @@ inline QAbstractOpenGLFunctionsPrivate *QAbstractOpenGLFunctionsPrivate::get(QAb
 class QOpenGLFunctions_1_0_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_1_0_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_1_0_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_1_0_Core; }
 
     // OpenGL 1.0 core functions
-    void (QOPENGLF_APIENTRYP Viewport)(GLint x, GLint y, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP DepthRange)(GLdouble nearVal, GLdouble farVal);
-    GLboolean (QOPENGLF_APIENTRYP IsEnabled)(GLenum cap);
-    void (QOPENGLF_APIENTRYP GetTexLevelParameteriv)(GLenum target, GLint level, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetTexLevelParameterfv)(GLenum target, GLint level, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetTexParameteriv)(GLenum target, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetTexParameterfv)(GLenum target, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels);
-    const GLubyte * (QOPENGLF_APIENTRYP GetString)(GLenum name);
-    void (QOPENGLF_APIENTRYP GetIntegerv)(GLenum pname, GLint *data);
-    void (QOPENGLF_APIENTRYP GetFloatv)(GLenum pname, GLfloat *data);
-    GLenum (QOPENGLF_APIENTRYP GetError)();
-    void (QOPENGLF_APIENTRYP GetDoublev)(GLenum pname, GLdouble *data);
-    void (QOPENGLF_APIENTRYP GetBooleanv)(GLenum pname, GLboolean *data);
-    void (QOPENGLF_APIENTRYP ReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP ReadBuffer)(GLenum src);
-    void (QOPENGLF_APIENTRYP PixelStorei)(GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP PixelStoref)(GLenum pname, GLfloat param);
-    void (QOPENGLF_APIENTRYP DepthFunc)(GLenum func);
-    void (QOPENGLF_APIENTRYP StencilOp)(GLenum fail, GLenum zfail, GLenum zpass);
-    void (QOPENGLF_APIENTRYP StencilFunc)(GLenum func, GLint ref, GLuint mask);
-    void (QOPENGLF_APIENTRYP LogicOp)(GLenum opcode);
-    void (QOPENGLF_APIENTRYP BlendFunc)(GLenum sfactor, GLenum dfactor);
-    void (QOPENGLF_APIENTRYP Flush)();
-    void (QOPENGLF_APIENTRYP Finish)();
-    void (QOPENGLF_APIENTRYP Enable)(GLenum cap);
-    void (QOPENGLF_APIENTRYP Disable)(GLenum cap);
-    void (QOPENGLF_APIENTRYP DepthMask)(GLboolean flag);
-    void (QOPENGLF_APIENTRYP ColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void (QOPENGLF_APIENTRYP StencilMask)(GLuint mask);
-    void (QOPENGLF_APIENTRYP ClearDepth)(GLdouble depth);
-    void (QOPENGLF_APIENTRYP ClearStencil)(GLint s);
-    void (QOPENGLF_APIENTRYP ClearColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void (QOPENGLF_APIENTRYP Clear)(GLbitfield mask);
-    void (QOPENGLF_APIENTRYP DrawBuffer)(GLenum buf);
-    void (QOPENGLF_APIENTRYP TexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP TexImage1D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP TexParameteriv)(GLenum target, GLenum pname, const GLint *params);
-    void (QOPENGLF_APIENTRYP TexParameteri)(GLenum target, GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP TexParameterfv)(GLenum target, GLenum pname, const GLfloat *params);
-    void (QOPENGLF_APIENTRYP TexParameterf)(GLenum target, GLenum pname, GLfloat param);
-    void (QOPENGLF_APIENTRYP Scissor)(GLint x, GLint y, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP PolygonMode)(GLenum face, GLenum mode);
-    void (QOPENGLF_APIENTRYP PointSize)(GLfloat size);
-    void (QOPENGLF_APIENTRYP LineWidth)(GLfloat width);
-    void (QOPENGLF_APIENTRYP Hint)(GLenum target, GLenum mode);
-    void (QOPENGLF_APIENTRYP FrontFace)(GLenum mode);
-    void (QOPENGLF_APIENTRYP CullFace)(GLenum mode);
+#define QT_OPENGL_1_0_FUNCTIONS(F) \
+    F(void, Viewport, (GLint x, GLint y, GLsizei width, GLsizei height)) \
+    F(void, DepthRange, (GLdouble nearVal, GLdouble farVal)) \
+    F(GLboolean, IsEnabled, (GLenum cap)) \
+    F(void, GetTexLevelParameteriv, (GLenum target, GLint level, GLenum pname, GLint *params)) \
+    F(void, GetTexLevelParameterfv, (GLenum target, GLint level, GLenum pname, GLfloat *params)) \
+    F(void, GetTexParameteriv, (GLenum target, GLenum pname, GLint *params)) \
+    F(void, GetTexParameterfv, (GLenum target, GLenum pname, GLfloat *params)) \
+    F(void, GetTexImage, (GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)) \
+    F(const GLubyte *, GetString, (GLenum name)) \
+    F(void, GetIntegerv, (GLenum pname, GLint *data)) \
+    F(void, GetFloatv, (GLenum pname, GLfloat *data)) \
+    F(GLenum, GetError, ()) \
+    F(void, GetDoublev, (GLenum pname, GLdouble *data)) \
+    F(void, GetBooleanv, (GLenum pname, GLboolean *data)) \
+    F(void, ReadPixels, (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)) \
+    F(void, ReadBuffer, (GLenum src)) \
+    F(void, PixelStorei, (GLenum pname, GLint param)) \
+    F(void, PixelStoref, (GLenum pname, GLfloat param)) \
+    F(void, DepthFunc, (GLenum func)) \
+    F(void, StencilOp, (GLenum fail, GLenum zfail, GLenum zpass)) \
+    F(void, StencilFunc, (GLenum func, GLint ref, GLuint mask)) \
+    F(void, LogicOp, (GLenum opcode)) \
+    F(void, BlendFunc, (GLenum sfactor, GLenum dfactor)) \
+    F(void, Flush, ()) \
+    F(void, Finish, ()) \
+    F(void, Enable, (GLenum cap)) \
+    F(void, Disable, (GLenum cap)) \
+    F(void, DepthMask, (GLboolean flag)) \
+    F(void, ColorMask, (GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)) \
+    F(void, StencilMask, (GLuint mask)) \
+    F(void, ClearDepth, (GLdouble depth)) \
+    F(void, ClearStencil, (GLint s)) \
+    F(void, ClearColor, (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)) \
+    F(void, Clear, (GLbitfield mask)) \
+    F(void, DrawBuffer, (GLenum buf)) \
+    F(void, TexImage2D, (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)) \
+    F(void, TexImage1D, (GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)) \
+    F(void, TexParameteriv, (GLenum target, GLenum pname, const GLint *params)) \
+    F(void, TexParameteri, (GLenum target, GLenum pname, GLint param)) \
+    F(void, TexParameterfv, (GLenum target, GLenum pname, const GLfloat *params)) \
+    F(void, TexParameterf, (GLenum target, GLenum pname, GLfloat param)) \
+    F(void, Scissor, (GLint x, GLint y, GLsizei width, GLsizei height)) \
+    F(void, PolygonMode, (GLenum face, GLenum mode)) \
+    F(void, PointSize, (GLfloat size)) \
+    F(void, LineWidth, (GLfloat width)) \
+    F(void, Hint, (GLenum target, GLenum mode)) \
+    F(void, FrontFace, (GLenum mode)) \
+    F(void, CullFace, (GLenum mode)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_1_0_FUNCTIONS);
 };
 
 class QOpenGLFunctions_1_1_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_1_1_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_1_1_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_1_1_Core; }
 
     // OpenGL 1.1 core functions
-    void (QOPENGLF_APIENTRYP Indexubv)(const GLubyte *c);
-    void (QOPENGLF_APIENTRYP Indexub)(GLubyte c);
-    GLboolean (QOPENGLF_APIENTRYP IsTexture)(GLuint texture);
-    void (QOPENGLF_APIENTRYP GenTextures)(GLsizei n, GLuint *textures);
-    void (QOPENGLF_APIENTRYP DeleteTextures)(GLsizei n, const GLuint *textures);
-    void (QOPENGLF_APIENTRYP BindTexture)(GLenum target, GLuint texture);
-    void (QOPENGLF_APIENTRYP TexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP TexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP CopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP CopyTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void (QOPENGLF_APIENTRYP CopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void (QOPENGLF_APIENTRYP CopyTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border);
-    void (QOPENGLF_APIENTRYP PolygonOffset)(GLfloat factor, GLfloat units);
-    void (QOPENGLF_APIENTRYP GetPointerv)(GLenum pname, GLvoid* *params);
-    void (QOPENGLF_APIENTRYP DrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices);
-    void (QOPENGLF_APIENTRYP DrawArrays)(GLenum mode, GLint first, GLsizei count);
+#define QT_OPENGL_1_1_FUNCTIONS(F) \
+    F(void, Indexubv, (const GLubyte *c)) \
+    F(void, Indexub, (GLubyte c)) \
+    F(GLboolean, IsTexture, (GLuint texture)) \
+    F(void, GenTextures, (GLsizei n, GLuint *textures)) \
+    F(void, DeleteTextures, (GLsizei n, const GLuint *textures)) \
+    F(void, BindTexture, (GLenum target, GLuint texture)) \
+    F(void, TexSubImage2D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)) \
+    F(void, TexSubImage1D, (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)) \
+    F(void, CopyTexSubImage2D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)) \
+    F(void, CopyTexSubImage1D, (GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)) \
+    F(void, CopyTexImage2D, (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)) \
+    F(void, CopyTexImage1D, (GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)) \
+    F(void, PolygonOffset, (GLfloat factor, GLfloat units)) \
+    F(void, GetPointerv, (GLenum pname, GLvoid* *params)) \
+    F(void, DrawElements, (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)) \
+    F(void, DrawArrays, (GLenum mode, GLint first, GLsizei count)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_1_1_FUNCTIONS);
 };
 
 class QOpenGLFunctions_1_2_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_1_2_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_1_2_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_1_2_Core; }
 
     // OpenGL 1.2 core functions
-    void (QOPENGLF_APIENTRYP CopyTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP TexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP TexImage3D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP DrawRangeElements)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices);
-    void (QOPENGLF_APIENTRYP BlendEquation)(GLenum mode);
-    void (QOPENGLF_APIENTRYP BlendColor)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
+#define QT_OPENGL_1_2_FUNCTIONS(F) \
+    F(void, CopyTexSubImage3D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)) \
+    F(void, TexSubImage3D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const GLvoid *pixels)) \
+    F(void, TexImage3D, (GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const GLvoid *pixels)) \
+    F(void, DrawRangeElements, (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices)) \
+    F(void, BlendEquation, (GLenum mode)) \
+    F(void, BlendColor, (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_1_2_FUNCTIONS);
 };
 
 class QOpenGLFunctions_1_3_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_1_3_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_1_3_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_1_3_Core; }
 
     // OpenGL 1.3 core functions
-    void (QOPENGLF_APIENTRYP GetCompressedTexImage)(GLenum target, GLint level, GLvoid *img);
-    void (QOPENGLF_APIENTRYP CompressedTexSubImage1D)(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void (QOPENGLF_APIENTRYP CompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void (QOPENGLF_APIENTRYP CompressedTexSubImage3D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data);
-    void (QOPENGLF_APIENTRYP CompressedTexImage1D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data);
-    void (QOPENGLF_APIENTRYP CompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data);
-    void (QOPENGLF_APIENTRYP CompressedTexImage3D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data);
-    void (QOPENGLF_APIENTRYP SampleCoverage)(GLfloat value, GLboolean invert);
-    void (QOPENGLF_APIENTRYP ActiveTexture)(GLenum texture);
+#define QT_OPENGL_1_3_FUNCTIONS(F) \
+    F(void, GetCompressedTexImage, (GLenum target, GLint level, GLvoid *img)) \
+    F(void, CompressedTexSubImage1D, (GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const GLvoid *data)) \
+    F(void, CompressedTexSubImage2D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data)) \
+    F(void, CompressedTexSubImage3D, (GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const GLvoid *data)) \
+    F(void, CompressedTexImage1D, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const GLvoid *data)) \
+    F(void, CompressedTexImage2D, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data)) \
+    F(void, CompressedTexImage3D, (GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const GLvoid *data)) \
+    F(void, SampleCoverage, (GLfloat value, GLboolean invert)) \
+    F(void, ActiveTexture, (GLenum texture)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_1_3_FUNCTIONS);
 };
 
 class QOpenGLFunctions_1_4_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_1_4_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_1_4_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_1_4_Core; }
 
     // OpenGL 1.4 core functions
-    void (QOPENGLF_APIENTRYP PointParameteriv)(GLenum pname, const GLint *params);
-    void (QOPENGLF_APIENTRYP PointParameteri)(GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP PointParameterfv)(GLenum pname, const GLfloat *params);
-    void (QOPENGLF_APIENTRYP PointParameterf)(GLenum pname, GLfloat param);
-    void (QOPENGLF_APIENTRYP MultiDrawElements)(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount);
-    void (QOPENGLF_APIENTRYP MultiDrawArrays)(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount);
-    void (QOPENGLF_APIENTRYP BlendFuncSeparate)(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha);
+#define QT_OPENGL_1_4_FUNCTIONS(F) \
+    F(void, PointParameteriv, (GLenum pname, const GLint *params)) \
+    F(void, PointParameteri, (GLenum pname, GLint param)) \
+    F(void, PointParameterfv, (GLenum pname, const GLfloat *params)) \
+    F(void, PointParameterf, (GLenum pname, GLfloat param)) \
+    F(void, MultiDrawElements, (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount)) \
+    F(void, MultiDrawArrays, (GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)) \
+    F(void, BlendFuncSeparate, (GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_1_4_FUNCTIONS);
 };
 
 class QOpenGLFunctions_1_5_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_1_5_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_1_5_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_1_5_Core; }
 
     // OpenGL 1.5 core functions
-    void (QOPENGLF_APIENTRYP GetBufferPointerv)(GLenum target, GLenum pname, GLvoid* *params);
-    void (QOPENGLF_APIENTRYP GetBufferParameteriv)(GLenum target, GLenum pname, GLint *params);
-    GLboolean (QOPENGLF_APIENTRYP UnmapBuffer)(GLenum target);
-    GLvoid* (QOPENGLF_APIENTRYP MapBuffer)(GLenum target, GLenum access);
-    void (QOPENGLF_APIENTRYP GetBufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data);
-    void (QOPENGLF_APIENTRYP BufferSubData)(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data);
-    void (QOPENGLF_APIENTRYP BufferData)(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage);
-    GLboolean (QOPENGLF_APIENTRYP IsBuffer)(GLuint buffer);
-    void (QOPENGLF_APIENTRYP GenBuffers)(GLsizei n, GLuint *buffers);
-    void (QOPENGLF_APIENTRYP DeleteBuffers)(GLsizei n, const GLuint *buffers);
-    void (QOPENGLF_APIENTRYP BindBuffer)(GLenum target, GLuint buffer);
-    void (QOPENGLF_APIENTRYP GetQueryObjectuiv)(GLuint id, GLenum pname, GLuint *params);
-    void (QOPENGLF_APIENTRYP GetQueryObjectiv)(GLuint id, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetQueryiv)(GLenum target, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP EndQuery)(GLenum target);
-    void (QOPENGLF_APIENTRYP BeginQuery)(GLenum target, GLuint id);
-    GLboolean (QOPENGLF_APIENTRYP IsQuery)(GLuint id);
-    void (QOPENGLF_APIENTRYP DeleteQueries)(GLsizei n, const GLuint *ids);
-    void (QOPENGLF_APIENTRYP GenQueries)(GLsizei n, GLuint *ids);
+#define QT_OPENGL_1_5_FUNCTIONS(F) \
+    F(void, GetBufferPointerv, (GLenum target, GLenum pname, GLvoid* *params)) \
+    F(void, GetBufferParameteriv, (GLenum target, GLenum pname, GLint *params)) \
+    F(GLboolean, UnmapBuffer, (GLenum target)) \
+    F(GLvoid*, MapBuffer, (GLenum target, GLenum access)) \
+    F(void, GetBufferSubData, (GLenum target, GLintptr offset, GLsizeiptr size, GLvoid *data)) \
+    F(void, BufferSubData, (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data)) \
+    F(void, BufferData, (GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage)) \
+    F(GLboolean, IsBuffer, (GLuint buffer)) \
+    F(void, GenBuffers, (GLsizei n, GLuint *buffers)) \
+    F(void, DeleteBuffers, (GLsizei n, const GLuint *buffers)) \
+    F(void, BindBuffer, (GLenum target, GLuint buffer)) \
+    F(void, GetQueryObjectuiv, (GLuint id, GLenum pname, GLuint *params)) \
+    F(void, GetQueryObjectiv, (GLuint id, GLenum pname, GLint *params)) \
+    F(void, GetQueryiv, (GLenum target, GLenum pname, GLint *params)) \
+    F(void, EndQuery, (GLenum target)) \
+    F(void, BeginQuery, (GLenum target, GLuint id)) \
+    F(GLboolean, IsQuery, (GLuint id)) \
+    F(void, DeleteQueries, (GLsizei n, const GLuint *ids)) \
+    F(void, GenQueries, (GLsizei n, GLuint *ids)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_1_5_FUNCTIONS);
 };
 
 class QOpenGLFunctions_2_0_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_2_0_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_2_0_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_2_0_Core; }
 
     // OpenGL 2.0 core functions
-    void (QOPENGLF_APIENTRYP VertexAttribPointer)(GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer);
-    void (QOPENGLF_APIENTRYP ValidateProgram)(GLuint program);
-    void (QOPENGLF_APIENTRYP UniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP Uniform4iv)(GLint location, GLsizei count, const GLint *value);
-    void (QOPENGLF_APIENTRYP Uniform3iv)(GLint location, GLsizei count, const GLint *value);
-    void (QOPENGLF_APIENTRYP Uniform2iv)(GLint location, GLsizei count, const GLint *value);
-    void (QOPENGLF_APIENTRYP Uniform1iv)(GLint location, GLsizei count, const GLint *value);
-    void (QOPENGLF_APIENTRYP Uniform4fv)(GLint location, GLsizei count, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP Uniform3fv)(GLint location, GLsizei count, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP Uniform2fv)(GLint location, GLsizei count, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP Uniform1fv)(GLint location, GLsizei count, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP Uniform4i)(GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void (QOPENGLF_APIENTRYP Uniform3i)(GLint location, GLint v0, GLint v1, GLint v2);
-    void (QOPENGLF_APIENTRYP Uniform2i)(GLint location, GLint v0, GLint v1);
-    void (QOPENGLF_APIENTRYP Uniform1i)(GLint location, GLint v0);
-    void (QOPENGLF_APIENTRYP Uniform4f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void (QOPENGLF_APIENTRYP Uniform3f)(GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void (QOPENGLF_APIENTRYP Uniform2f)(GLint location, GLfloat v0, GLfloat v1);
-    void (QOPENGLF_APIENTRYP Uniform1f)(GLint location, GLfloat v0);
-    void (QOPENGLF_APIENTRYP UseProgram)(GLuint program);
-    void (QOPENGLF_APIENTRYP ShaderSource)(GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length);
-    void (QOPENGLF_APIENTRYP LinkProgram)(GLuint program);
-    GLboolean (QOPENGLF_APIENTRYP IsShader)(GLuint shader);
-    GLboolean (QOPENGLF_APIENTRYP IsProgram)(GLuint program);
-    void (QOPENGLF_APIENTRYP GetVertexAttribPointerv)(GLuint index, GLenum pname, GLvoid* *pointer);
-    void (QOPENGLF_APIENTRYP GetVertexAttribiv)(GLuint index, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetVertexAttribfv)(GLuint index, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetVertexAttribdv)(GLuint index, GLenum pname, GLdouble *params);
-    void (QOPENGLF_APIENTRYP GetUniformiv)(GLuint program, GLint location, GLint *params);
-    void (QOPENGLF_APIENTRYP GetUniformfv)(GLuint program, GLint location, GLfloat *params);
-    GLint (QOPENGLF_APIENTRYP GetUniformLocation)(GLuint program, const GLchar *name);
-    void (QOPENGLF_APIENTRYP GetShaderSource)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source);
-    void (QOPENGLF_APIENTRYP GetShaderInfoLog)(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void (QOPENGLF_APIENTRYP GetShaderiv)(GLuint shader, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetProgramInfoLog)(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void (QOPENGLF_APIENTRYP GetProgramiv)(GLuint program, GLenum pname, GLint *params);
-    GLint (QOPENGLF_APIENTRYP GetAttribLocation)(GLuint program, const GLchar *name);
-    void (QOPENGLF_APIENTRYP GetAttachedShaders)(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders);
-    void (QOPENGLF_APIENTRYP GetActiveUniform)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void (QOPENGLF_APIENTRYP GetActiveAttrib)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name);
-    void (QOPENGLF_APIENTRYP EnableVertexAttribArray)(GLuint index);
-    void (QOPENGLF_APIENTRYP DisableVertexAttribArray)(GLuint index);
-    void (QOPENGLF_APIENTRYP DetachShader)(GLuint program, GLuint shader);
-    void (QOPENGLF_APIENTRYP DeleteShader)(GLuint shader);
-    void (QOPENGLF_APIENTRYP DeleteProgram)(GLuint program);
-    GLuint (QOPENGLF_APIENTRYP CreateShader)(GLenum type);
-    GLuint (QOPENGLF_APIENTRYP CreateProgram)();
-    void (QOPENGLF_APIENTRYP CompileShader)(GLuint shader);
-    void (QOPENGLF_APIENTRYP BindAttribLocation)(GLuint program, GLuint index, const GLchar *name);
-    void (QOPENGLF_APIENTRYP AttachShader)(GLuint program, GLuint shader);
-    void (QOPENGLF_APIENTRYP StencilMaskSeparate)(GLenum face, GLuint mask);
-    void (QOPENGLF_APIENTRYP StencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void (QOPENGLF_APIENTRYP StencilOpSeparate)(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass);
-    void (QOPENGLF_APIENTRYP DrawBuffers)(GLsizei n, const GLenum *bufs);
-    void (QOPENGLF_APIENTRYP BlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha);
-    void (QOPENGLF_APIENTRYP VertexAttrib4usv)(GLuint index, const GLushort *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4uiv)(GLuint index, const GLuint *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4ubv)(GLuint index, const GLubyte *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4sv)(GLuint index, const GLshort *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4s)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-    void (QOPENGLF_APIENTRYP VertexAttrib4iv)(GLuint index, const GLint *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4fv)(GLuint index, const GLfloat *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4f)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void (QOPENGLF_APIENTRYP VertexAttrib4dv)(GLuint index, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void (QOPENGLF_APIENTRYP VertexAttrib4bv)(GLuint index, const GLbyte *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4Nusv)(GLuint index, const GLushort *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4Nuiv)(GLuint index, const GLuint *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4Nubv)(GLuint index, const GLubyte *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4Nub)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-    void (QOPENGLF_APIENTRYP VertexAttrib4Nsv)(GLuint index, const GLshort *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4Niv)(GLuint index, const GLint *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4Nbv)(GLuint index, const GLbyte *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib3sv)(GLuint index, const GLshort *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib3s)(GLuint index, GLshort x, GLshort y, GLshort z);
-    void (QOPENGLF_APIENTRYP VertexAttrib3fv)(GLuint index, const GLfloat *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib3f)(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-    void (QOPENGLF_APIENTRYP VertexAttrib3dv)(GLuint index, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void (QOPENGLF_APIENTRYP VertexAttrib2sv)(GLuint index, const GLshort *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib2s)(GLuint index, GLshort x, GLshort y);
-    void (QOPENGLF_APIENTRYP VertexAttrib2fv)(GLuint index, const GLfloat *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib2f)(GLuint index, GLfloat x, GLfloat y);
-    void (QOPENGLF_APIENTRYP VertexAttrib2dv)(GLuint index, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib2d)(GLuint index, GLdouble x, GLdouble y);
-    void (QOPENGLF_APIENTRYP VertexAttrib1sv)(GLuint index, const GLshort *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib1s)(GLuint index, GLshort x);
-    void (QOPENGLF_APIENTRYP VertexAttrib1fv)(GLuint index, const GLfloat *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib1f)(GLuint index, GLfloat x);
-    void (QOPENGLF_APIENTRYP VertexAttrib1dv)(GLuint index, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib1d)(GLuint index, GLdouble x);
+#define QT_OPENGL_2_0_FUNCTIONS(F) \
+    F(void, VertexAttribPointer, (GLuint index, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid *pointer)) \
+    F(void, ValidateProgram, (GLuint program)) \
+    F(void, UniformMatrix4fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, UniformMatrix3fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, UniformMatrix2fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, Uniform4iv, (GLint location, GLsizei count, const GLint *value)) \
+    F(void, Uniform3iv, (GLint location, GLsizei count, const GLint *value)) \
+    F(void, Uniform2iv, (GLint location, GLsizei count, const GLint *value)) \
+    F(void, Uniform1iv, (GLint location, GLsizei count, const GLint *value)) \
+    F(void, Uniform4fv, (GLint location, GLsizei count, const GLfloat *value)) \
+    F(void, Uniform3fv, (GLint location, GLsizei count, const GLfloat *value)) \
+    F(void, Uniform2fv, (GLint location, GLsizei count, const GLfloat *value)) \
+    F(void, Uniform1fv, (GLint location, GLsizei count, const GLfloat *value)) \
+    F(void, Uniform4i, (GLint location, GLint v0, GLint v1, GLint v2, GLint v3)) \
+    F(void, Uniform3i, (GLint location, GLint v0, GLint v1, GLint v2)) \
+    F(void, Uniform2i, (GLint location, GLint v0, GLint v1)) \
+    F(void, Uniform1i, (GLint location, GLint v0)) \
+    F(void, Uniform4f, (GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)) \
+    F(void, Uniform3f, (GLint location, GLfloat v0, GLfloat v1, GLfloat v2)) \
+    F(void, Uniform2f, (GLint location, GLfloat v0, GLfloat v1)) \
+    F(void, Uniform1f, (GLint location, GLfloat v0)) \
+    F(void, UseProgram, (GLuint program)) \
+    F(void, ShaderSource, (GLuint shader, GLsizei count, const GLchar* const *string, const GLint *length)) \
+    F(void, LinkProgram, (GLuint program)) \
+    F(GLboolean, IsShader, (GLuint shader)) \
+    F(GLboolean, IsProgram, (GLuint program)) \
+    F(void, GetVertexAttribPointerv, (GLuint index, GLenum pname, GLvoid* *pointer)) \
+    F(void, GetVertexAttribiv, (GLuint index, GLenum pname, GLint *params)) \
+    F(void, GetVertexAttribfv, (GLuint index, GLenum pname, GLfloat *params)) \
+    F(void, GetVertexAttribdv, (GLuint index, GLenum pname, GLdouble *params)) \
+    F(void, GetUniformiv, (GLuint program, GLint location, GLint *params)) \
+    F(void, GetUniformfv, (GLuint program, GLint location, GLfloat *params)) \
+    F(GLint, GetUniformLocation, (GLuint program, const GLchar *name)) \
+    F(void, GetShaderSource, (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)) \
+    F(void, GetShaderInfoLog, (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)) \
+    F(void, GetShaderiv, (GLuint shader, GLenum pname, GLint *params)) \
+    F(void, GetProgramInfoLog, (GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)) \
+    F(void, GetProgramiv, (GLuint program, GLenum pname, GLint *params)) \
+    F(GLint, GetAttribLocation, (GLuint program, const GLchar *name)) \
+    F(void, GetAttachedShaders, (GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)) \
+    F(void, GetActiveUniform, (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)) \
+    F(void, GetActiveAttrib, (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)) \
+    F(void, EnableVertexAttribArray, (GLuint index)) \
+    F(void, DisableVertexAttribArray, (GLuint index)) \
+    F(void, DetachShader, (GLuint program, GLuint shader)) \
+    F(void, DeleteShader, (GLuint shader)) \
+    F(void, DeleteProgram, (GLuint program)) \
+    F(GLuint, CreateShader, (GLenum type)) \
+    F(GLuint, CreateProgram, ()) \
+    F(void, CompileShader, (GLuint shader)) \
+    F(void, BindAttribLocation, (GLuint program, GLuint index, const GLchar *name)) \
+    F(void, AttachShader, (GLuint program, GLuint shader)) \
+    F(void, StencilMaskSeparate, (GLenum face, GLuint mask)) \
+    F(void, StencilFuncSeparate, (GLenum face, GLenum func, GLint ref, GLuint mask)) \
+    F(void, StencilOpSeparate, (GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)) \
+    F(void, DrawBuffers, (GLsizei n, const GLenum *bufs)) \
+    F(void, BlendEquationSeparate, (GLenum modeRGB, GLenum modeAlpha)) \
+    F(void, VertexAttrib4usv, (GLuint index, const GLushort *v)) \
+    F(void, VertexAttrib4uiv, (GLuint index, const GLuint *v)) \
+    F(void, VertexAttrib4ubv, (GLuint index, const GLubyte *v)) \
+    F(void, VertexAttrib4sv, (GLuint index, const GLshort *v)) \
+    F(void, VertexAttrib4s, (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)) \
+    F(void, VertexAttrib4iv, (GLuint index, const GLint *v)) \
+    F(void, VertexAttrib4fv, (GLuint index, const GLfloat *v)) \
+    F(void, VertexAttrib4f, (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
+    F(void, VertexAttrib4dv, (GLuint index, const GLdouble *v)) \
+    F(void, VertexAttrib4d, (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
+    F(void, VertexAttrib4bv, (GLuint index, const GLbyte *v)) \
+    F(void, VertexAttrib4Nusv, (GLuint index, const GLushort *v)) \
+    F(void, VertexAttrib4Nuiv, (GLuint index, const GLuint *v)) \
+    F(void, VertexAttrib4Nubv, (GLuint index, const GLubyte *v)) \
+    F(void, VertexAttrib4Nub, (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)) \
+    F(void, VertexAttrib4Nsv, (GLuint index, const GLshort *v)) \
+    F(void, VertexAttrib4Niv, (GLuint index, const GLint *v)) \
+    F(void, VertexAttrib4Nbv, (GLuint index, const GLbyte *v)) \
+    F(void, VertexAttrib3sv, (GLuint index, const GLshort *v)) \
+    F(void, VertexAttrib3s, (GLuint index, GLshort x, GLshort y, GLshort z)) \
+    F(void, VertexAttrib3fv, (GLuint index, const GLfloat *v)) \
+    F(void, VertexAttrib3f, (GLuint index, GLfloat x, GLfloat y, GLfloat z)) \
+    F(void, VertexAttrib3dv, (GLuint index, const GLdouble *v)) \
+    F(void, VertexAttrib3d, (GLuint index, GLdouble x, GLdouble y, GLdouble z)) \
+    F(void, VertexAttrib2sv, (GLuint index, const GLshort *v)) \
+    F(void, VertexAttrib2s, (GLuint index, GLshort x, GLshort y)) \
+    F(void, VertexAttrib2fv, (GLuint index, const GLfloat *v)) \
+    F(void, VertexAttrib2f, (GLuint index, GLfloat x, GLfloat y)) \
+    F(void, VertexAttrib2dv, (GLuint index, const GLdouble *v)) \
+    F(void, VertexAttrib2d, (GLuint index, GLdouble x, GLdouble y)) \
+    F(void, VertexAttrib1sv, (GLuint index, const GLshort *v)) \
+    F(void, VertexAttrib1s, (GLuint index, GLshort x)) \
+    F(void, VertexAttrib1fv, (GLuint index, const GLfloat *v)) \
+    F(void, VertexAttrib1f, (GLuint index, GLfloat x)) \
+    F(void, VertexAttrib1dv, (GLuint index, const GLdouble *v)) \
+    F(void, VertexAttrib1d, (GLuint index, GLdouble x)) \
+
+    QT_OPENGL_DECLARE(QT_OPENGL_2_0_FUNCTIONS);
 };
 
 class QOpenGLFunctions_2_1_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_2_1_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_2_1_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_2_1_Core; }
 
     // OpenGL 2.1 core functions
-    void (QOPENGLF_APIENTRYP UniformMatrix4x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix3x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix4x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix2x4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix3x2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix2x3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
+#define QT_OPENGL_2_1_FUNCTIONS(F) \
+    F(void, UniformMatrix4x3fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, UniformMatrix3x4fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, UniformMatrix4x2fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, UniformMatrix2x4fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, UniformMatrix3x2fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, UniformMatrix2x3fv, (GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_2_1_FUNCTIONS);
 };
 
 class QOpenGLFunctions_3_0_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_3_0_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_3_0_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_3_0_Core; }
 
     // OpenGL 3.0 core functions
-    GLboolean (QOPENGLF_APIENTRYP IsVertexArray)(GLuint array);
-    void (QOPENGLF_APIENTRYP GenVertexArrays)(GLsizei n, GLuint *arrays);
-    void (QOPENGLF_APIENTRYP DeleteVertexArrays)(GLsizei n, const GLuint *arrays);
-    void (QOPENGLF_APIENTRYP BindVertexArray)(GLuint array);
-    void (QOPENGLF_APIENTRYP FlushMappedBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length);
-    GLvoid* (QOPENGLF_APIENTRYP MapBufferRange)(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access);
-    void (QOPENGLF_APIENTRYP FramebufferTextureLayer)(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void (QOPENGLF_APIENTRYP RenderbufferStorageMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP BlitFramebuffer)(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void (QOPENGLF_APIENTRYP GenerateMipmap)(GLenum target);
-    void (QOPENGLF_APIENTRYP GetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP FramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void (QOPENGLF_APIENTRYP FramebufferTexture3D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset);
-    void (QOPENGLF_APIENTRYP FramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void (QOPENGLF_APIENTRYP FramebufferTexture1D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    GLenum (QOPENGLF_APIENTRYP CheckFramebufferStatus)(GLenum target);
-    void (QOPENGLF_APIENTRYP GenFramebuffers)(GLsizei n, GLuint *framebuffers);
-    void (QOPENGLF_APIENTRYP DeleteFramebuffers)(GLsizei n, const GLuint *framebuffers);
-    void (QOPENGLF_APIENTRYP BindFramebuffer)(GLenum target, GLuint framebuffer);
-    GLboolean (QOPENGLF_APIENTRYP IsFramebuffer)(GLuint framebuffer);
-    void (QOPENGLF_APIENTRYP GetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP RenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP GenRenderbuffers)(GLsizei n, GLuint *renderbuffers);
-    void (QOPENGLF_APIENTRYP DeleteRenderbuffers)(GLsizei n, const GLuint *renderbuffers);
-    void (QOPENGLF_APIENTRYP BindRenderbuffer)(GLenum target, GLuint renderbuffer);
-    GLboolean (QOPENGLF_APIENTRYP IsRenderbuffer)(GLuint renderbuffer);
-    const GLubyte * (QOPENGLF_APIENTRYP GetStringi)(GLenum name, GLuint index);
-    void (QOPENGLF_APIENTRYP ClearBufferfi)(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
-    void (QOPENGLF_APIENTRYP ClearBufferfv)(GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ClearBufferuiv)(GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ClearBufferiv)(GLenum buffer, GLint drawbuffer, const GLint *value);
-    void (QOPENGLF_APIENTRYP GetTexParameterIuiv)(GLenum target, GLenum pname, GLuint *params);
-    void (QOPENGLF_APIENTRYP GetTexParameterIiv)(GLenum target, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP TexParameterIuiv)(GLenum target, GLenum pname, const GLuint *params);
-    void (QOPENGLF_APIENTRYP TexParameterIiv)(GLenum target, GLenum pname, const GLint *params);
-    void (QOPENGLF_APIENTRYP Uniform4uiv)(GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP Uniform3uiv)(GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP Uniform2uiv)(GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP Uniform1uiv)(GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP Uniform4ui)(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void (QOPENGLF_APIENTRYP Uniform3ui)(GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void (QOPENGLF_APIENTRYP Uniform2ui)(GLint location, GLuint v0, GLuint v1);
-    void (QOPENGLF_APIENTRYP Uniform1ui)(GLint location, GLuint v0);
-    GLint (QOPENGLF_APIENTRYP GetFragDataLocation)(GLuint program, const GLchar *name);
-    void (QOPENGLF_APIENTRYP BindFragDataLocation)(GLuint program, GLuint color, const GLchar *name);
-    void (QOPENGLF_APIENTRYP GetUniformuiv)(GLuint program, GLint location, GLuint *params);
-    void (QOPENGLF_APIENTRYP GetVertexAttribIuiv)(GLuint index, GLenum pname, GLuint *params);
-    void (QOPENGLF_APIENTRYP GetVertexAttribIiv)(GLuint index, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP VertexAttribIPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void (QOPENGLF_APIENTRYP EndConditionalRender)();
-    void (QOPENGLF_APIENTRYP BeginConditionalRender)(GLuint id, GLenum mode);
-    void (QOPENGLF_APIENTRYP ClampColor)(GLenum target, GLenum clamp);
-    void (QOPENGLF_APIENTRYP GetTransformFeedbackVarying)(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name);
-    void (QOPENGLF_APIENTRYP TransformFeedbackVaryings)(GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode);
-    void (QOPENGLF_APIENTRYP BindBufferBase)(GLenum target, GLuint index, GLuint buffer);
-    void (QOPENGLF_APIENTRYP BindBufferRange)(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void (QOPENGLF_APIENTRYP EndTransformFeedback)();
-    void (QOPENGLF_APIENTRYP BeginTransformFeedback)(GLenum primitiveMode);
-    GLboolean (QOPENGLF_APIENTRYP IsEnabledi)(GLenum target, GLuint index);
-    void (QOPENGLF_APIENTRYP Disablei)(GLenum target, GLuint index);
-    void (QOPENGLF_APIENTRYP Enablei)(GLenum target, GLuint index);
-    void (QOPENGLF_APIENTRYP GetIntegeri_v)(GLenum target, GLuint index, GLint *data);
-    void (QOPENGLF_APIENTRYP GetBooleani_v)(GLenum target, GLuint index, GLboolean *data);
-    void (QOPENGLF_APIENTRYP ColorMaski)(GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a);
-    void (QOPENGLF_APIENTRYP VertexAttribI4usv)(GLuint index, const GLushort *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI4ubv)(GLuint index, const GLubyte *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI4sv)(GLuint index, const GLshort *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI4bv)(GLuint index, const GLbyte *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI4uiv)(GLuint index, const GLuint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI3uiv)(GLuint index, const GLuint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI2uiv)(GLuint index, const GLuint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI1uiv)(GLuint index, const GLuint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI4iv)(GLuint index, const GLint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI3iv)(GLuint index, const GLint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI2iv)(GLuint index, const GLint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI1iv)(GLuint index, const GLint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-    void (QOPENGLF_APIENTRYP VertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z);
-    void (QOPENGLF_APIENTRYP VertexAttribI2ui)(GLuint index, GLuint x, GLuint y);
-    void (QOPENGLF_APIENTRYP VertexAttribI1ui)(GLuint index, GLuint x);
-    void (QOPENGLF_APIENTRYP VertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w);
-    void (QOPENGLF_APIENTRYP VertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z);
-    void (QOPENGLF_APIENTRYP VertexAttribI2i)(GLuint index, GLint x, GLint y);
-    void (QOPENGLF_APIENTRYP VertexAttribI1i)(GLuint index, GLint x);
+#define QT_OPENGL_3_0_FUNCTIONS(F) \
+    F(GLboolean, IsVertexArray, (GLuint array)) \
+    F(void, GenVertexArrays, (GLsizei n, GLuint *arrays)) \
+    F(void, DeleteVertexArrays, (GLsizei n, const GLuint *arrays)) \
+    F(void, BindVertexArray, (GLuint array)) \
+    F(void, FlushMappedBufferRange, (GLenum target, GLintptr offset, GLsizeiptr length)) \
+    F(GLvoid *, MapBufferRange, (GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)) \
+    F(void, FramebufferTextureLayer, (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)) \
+    F(void, RenderbufferStorageMultisample, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)) \
+    F(void, BlitFramebuffer, (GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)) \
+    F(void, GenerateMipmap, (GLenum target)) \
+    F(void, GetFramebufferAttachmentParameteriv, (GLenum target, GLenum attachment, GLenum pname, GLint *params)) \
+    F(void, FramebufferRenderbuffer, (GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)) \
+    F(void, FramebufferTexture3D, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)) \
+    F(void, FramebufferTexture2D, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)) \
+    F(void, FramebufferTexture1D, (GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)) \
+    F(GLenum, CheckFramebufferStatus, (GLenum target)) \
+    F(void, GenFramebuffers, (GLsizei n, GLuint *framebuffers)) \
+    F(void, DeleteFramebuffers, (GLsizei n, const GLuint *framebuffers)) \
+    F(void, BindFramebuffer, (GLenum target, GLuint framebuffer)) \
+    F(GLboolean, IsFramebuffer, (GLuint framebuffer)) \
+    F(void, GetRenderbufferParameteriv, (GLenum target, GLenum pname, GLint *params)) \
+    F(void, RenderbufferStorage, (GLenum target, GLenum internalformat, GLsizei width, GLsizei height)) \
+    F(void, GenRenderbuffers, (GLsizei n, GLuint *renderbuffers)) \
+    F(void, DeleteRenderbuffers, (GLsizei n, const GLuint *renderbuffers)) \
+    F(void, BindRenderbuffer, (GLenum target, GLuint renderbuffer)) \
+    F(GLboolean, IsRenderbuffer, (GLuint renderbuffer)) \
+    F(const GLubyte *, GetStringi, (GLenum name, GLuint index)) \
+    F(void, ClearBufferfi, (GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)) \
+    F(void, ClearBufferfv, (GLenum buffer, GLint drawbuffer, const GLfloat *value)) \
+    F(void, ClearBufferuiv, (GLenum buffer, GLint drawbuffer, const GLuint *value)) \
+    F(void, ClearBufferiv, (GLenum buffer, GLint drawbuffer, const GLint *value)) \
+    F(void, GetTexParameterIuiv, (GLenum target, GLenum pname, GLuint *params)) \
+    F(void, GetTexParameterIiv, (GLenum target, GLenum pname, GLint *params)) \
+    F(void, TexParameterIuiv, (GLenum target, GLenum pname, const GLuint *params)) \
+    F(void, TexParameterIiv, (GLenum target, GLenum pname, const GLint *params)) \
+    F(void, Uniform4uiv, (GLint location, GLsizei count, const GLuint *value)) \
+    F(void, Uniform3uiv, (GLint location, GLsizei count, const GLuint *value)) \
+    F(void, Uniform2uiv, (GLint location, GLsizei count, const GLuint *value)) \
+    F(void, Uniform1uiv, (GLint location, GLsizei count, const GLuint *value)) \
+    F(void, Uniform4ui, (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)) \
+    F(void, Uniform3ui, (GLint location, GLuint v0, GLuint v1, GLuint v2)) \
+    F(void, Uniform2ui, (GLint location, GLuint v0, GLuint v1)) \
+    F(void, Uniform1ui, (GLint location, GLuint v0)) \
+    F(GLint, GetFragDataLocation, (GLuint program, const GLchar *name)) \
+    F(void, BindFragDataLocation, (GLuint program, GLuint color, const GLchar *name)) \
+    F(void, GetUniformuiv, (GLuint program, GLint location, GLuint *params)) \
+    F(void, GetVertexAttribIuiv, (GLuint index, GLenum pname, GLuint *params)) \
+    F(void, GetVertexAttribIiv, (GLuint index, GLenum pname, GLint *params)) \
+    F(void, VertexAttribIPointer, (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)) \
+    F(void, EndConditionalRender, ()) \
+    F(void, BeginConditionalRender, (GLuint id, GLenum mode)) \
+    F(void, ClampColor, (GLenum target, GLenum clamp)) \
+    F(void, GetTransformFeedbackVarying, (GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)) \
+    F(void, TransformFeedbackVaryings, (GLuint program, GLsizei count, const GLchar* const *varyings, GLenum bufferMode)) \
+    F(void, BindBufferBase, (GLenum target, GLuint index, GLuint buffer)) \
+    F(void, BindBufferRange, (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)) \
+    F(void, EndTransformFeedback, ()) \
+    F(void, BeginTransformFeedback, (GLenum primitiveMode)) \
+    F(GLboolean, IsEnabledi, (GLenum target, GLuint index)) \
+    F(void, Disablei, (GLenum target, GLuint index)) \
+    F(void, Enablei, (GLenum target, GLuint index)) \
+    F(void, GetIntegeri_v,(GLenum target, GLuint index, GLint *data)) \
+    F(void, GetBooleani_v,(GLenum target, GLuint index, GLboolean *data)) \
+    F(void, ColorMaski, (GLuint index, GLboolean r, GLboolean g, GLboolean b, GLboolean a)) \
+    F(void, VertexAttribI4usv, (GLuint index, const GLushort *v)) \
+    F(void, VertexAttribI4ubv, (GLuint index, const GLubyte *v)) \
+    F(void, VertexAttribI4sv, (GLuint index, const GLshort *v)) \
+    F(void, VertexAttribI4bv, (GLuint index, const GLbyte *v)) \
+    F(void, VertexAttribI4uiv, (GLuint index, const GLuint *v)) \
+    F(void, VertexAttribI3uiv, (GLuint index, const GLuint *v)) \
+    F(void, VertexAttribI2uiv, (GLuint index, const GLuint *v)) \
+    F(void, VertexAttribI1uiv, (GLuint index, const GLuint *v)) \
+    F(void, VertexAttribI4iv, (GLuint index, const GLint *v)) \
+    F(void, VertexAttribI3iv, (GLuint index, const GLint *v)) \
+    F(void, VertexAttribI2iv, (GLuint index, const GLint *v)) \
+    F(void, VertexAttribI1iv, (GLuint index, const GLint *v)) \
+    F(void, VertexAttribI4ui, (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)) \
+    F(void, VertexAttribI3ui, (GLuint index, GLuint x, GLuint y, GLuint z)) \
+    F(void, VertexAttribI2ui, (GLuint index, GLuint x, GLuint y)) \
+    F(void, VertexAttribI1ui, (GLuint index, GLuint x)) \
+    F(void, VertexAttribI4i, (GLuint index, GLint x, GLint y, GLint z, GLint w)) \
+    F(void, VertexAttribI3i, (GLuint index, GLint x, GLint y, GLint z)) \
+    F(void, VertexAttribI2i, (GLuint index, GLint x, GLint y)) \
+    F(void, VertexAttribI1i, (GLuint index, GLint x)) \
+
+    QT_OPENGL_DECLARE(QT_OPENGL_3_0_FUNCTIONS);
 };
 
 class QOpenGLFunctions_3_1_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_3_1_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_3_1_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_3_1_Core; }
 
     // OpenGL 3.1 core functions
-    void (QOPENGLF_APIENTRYP CopyBufferSubData)(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size);
-    void (QOPENGLF_APIENTRYP UniformBlockBinding)(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding);
-    void (QOPENGLF_APIENTRYP GetActiveUniformBlockName)(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName);
-    void (QOPENGLF_APIENTRYP GetActiveUniformBlockiv)(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params);
-    GLuint (QOPENGLF_APIENTRYP GetUniformBlockIndex)(GLuint program, const GLchar *uniformBlockName);
-    void (QOPENGLF_APIENTRYP GetActiveUniformName)(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName);
-    void (QOPENGLF_APIENTRYP GetActiveUniformsiv)(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetUniformIndices)(GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices);
-    void (QOPENGLF_APIENTRYP PrimitiveRestartIndex)(GLuint index);
-    void (QOPENGLF_APIENTRYP TexBuffer)(GLenum target, GLenum internalformat, GLuint buffer);
-    void (QOPENGLF_APIENTRYP DrawElementsInstanced)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount);
-    void (QOPENGLF_APIENTRYP DrawArraysInstanced)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount);
+#define QT_OPENGL_3_1_FUNCTIONS(F) \
+    F(void, CopyBufferSubData, (GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)) \
+    F(void, UniformBlockBinding, (GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)) \
+    F(void, GetActiveUniformBlockName, (GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)) \
+    F(void, GetActiveUniformBlockiv, (GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)) \
+    F(GLuint, GetUniformBlockIndex, (GLuint program, const GLchar *uniformBlockName)) \
+    F(void, GetActiveUniformName, (GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)) \
+    F(void, GetActiveUniformsiv, (GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)) \
+    F(void, GetUniformIndices, (GLuint program, GLsizei uniformCount, const GLchar* const *uniformNames, GLuint *uniformIndices)) \
+    F(void, PrimitiveRestartIndex, (GLuint index)) \
+    F(void, TexBuffer, (GLenum target, GLenum internalformat, GLuint buffer)) \
+    F(void, DrawElementsInstanced, (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount)) \
+    F(void, DrawArraysInstanced, (GLenum mode, GLint first, GLsizei count, GLsizei instancecount)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_3_1_FUNCTIONS);
 };
 
 class QOpenGLFunctions_3_2_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_3_2_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_3_2_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_3_2_Core; }
 
     // OpenGL 3.2 core functions
-    void (QOPENGLF_APIENTRYP SampleMaski)(GLuint maskNumber, GLbitfield mask);
-    void (QOPENGLF_APIENTRYP GetMultisamplefv)(GLenum pname, GLuint index, GLfloat *val);
-    void (QOPENGLF_APIENTRYP TexImage3DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void (QOPENGLF_APIENTRYP TexImage2DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void (QOPENGLF_APIENTRYP GetSynciv)(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values);
-    void (QOPENGLF_APIENTRYP GetInteger64v)(GLenum pname, GLint64 *data);
-    void (QOPENGLF_APIENTRYP WaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    GLenum (QOPENGLF_APIENTRYP ClientWaitSync)(GLsync sync, GLbitfield flags, GLuint64 timeout);
-    void (QOPENGLF_APIENTRYP DeleteSync)(GLsync sync);
-    GLboolean (QOPENGLF_APIENTRYP IsSync)(GLsync sync);
-    GLsync (QOPENGLF_APIENTRYP FenceSync)(GLenum condition, GLbitfield flags);
-    void (QOPENGLF_APIENTRYP ProvokingVertex)(GLenum mode);
-    void (QOPENGLF_APIENTRYP MultiDrawElementsBaseVertex)(GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex);
-    void (QOPENGLF_APIENTRYP DrawElementsInstancedBaseVertex)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex);
-    void (QOPENGLF_APIENTRYP DrawRangeElementsBaseVertex)(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void (QOPENGLF_APIENTRYP DrawElementsBaseVertex)(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex);
-    void (QOPENGLF_APIENTRYP FramebufferTexture)(GLenum target, GLenum attachment, GLuint texture, GLint level);
-    void (QOPENGLF_APIENTRYP GetBufferParameteri64v)(GLenum target, GLenum pname, GLint64 *params);
-    void (QOPENGLF_APIENTRYP GetInteger64i_v)(GLenum target, GLuint index, GLint64 *data);
+#define QT_OPENGL_3_2_FUNCTIONS(F) \
+    F(void, SampleMaski, (GLuint maskNumber, GLbitfield mask)) \
+    F(void, GetMultisamplefv, (GLenum pname, GLuint index, GLfloat *val)) \
+    F(void, TexImage3DMultisample, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)) \
+    F(void, TexImage2DMultisample, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)) \
+    F(void, GetSynciv, (GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)) \
+    F(void, GetInteger64v, (GLenum pname, GLint64 *data)) \
+    F(void, WaitSync, (GLsync sync, GLbitfield flags, GLuint64 timeout)) \
+    F(GLenum, ClientWaitSync, (GLsync sync, GLbitfield flags, GLuint64 timeout)) \
+    F(void, DeleteSync, (GLsync sync)) \
+    F(GLboolean, IsSync, (GLsync sync)) \
+    F(GLsync, FenceSync, (GLenum condition, GLbitfield flags)) \
+    F(void, ProvokingVertex, (GLenum mode)) \
+    F(void, MultiDrawElementsBaseVertex, (GLenum mode, const GLsizei *count, GLenum type, const GLvoid* const *indices, GLsizei drawcount, const GLint *basevertex)) \
+    F(void, DrawElementsInstancedBaseVertex, (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLsizei instancecount, GLint basevertex)) \
+    F(void, DrawRangeElementsBaseVertex, (GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)) \
+    F(void, DrawElementsBaseVertex, (GLenum mode, GLsizei count, GLenum type, const GLvoid *indices, GLint basevertex)) \
+    F(void, FramebufferTexture, (GLenum target, GLenum attachment, GLuint texture, GLint level)) \
+    F(void, GetBufferParameteri64v, (GLenum target, GLenum pname, GLint64 *params)) \
+    F(void, GetInteger64i_v,(GLenum target, GLuint index, GLint64 *data))
 
+    QT_OPENGL_DECLARE(QT_OPENGL_3_2_FUNCTIONS);
 };
 
 class QOpenGLFunctions_3_3_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_3_3_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_3_3_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_3_3_Core; }
 
     // OpenGL 3.3 core functions
-    void (QOPENGLF_APIENTRYP VertexAttribP4uiv)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void (QOPENGLF_APIENTRYP VertexAttribP4ui)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void (QOPENGLF_APIENTRYP VertexAttribP3uiv)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void (QOPENGLF_APIENTRYP VertexAttribP3ui)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void (QOPENGLF_APIENTRYP VertexAttribP2uiv)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void (QOPENGLF_APIENTRYP VertexAttribP2ui)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void (QOPENGLF_APIENTRYP VertexAttribP1uiv)(GLuint index, GLenum type, GLboolean normalized, const GLuint *value);
-    void (QOPENGLF_APIENTRYP VertexAttribP1ui)(GLuint index, GLenum type, GLboolean normalized, GLuint value);
-    void (QOPENGLF_APIENTRYP SecondaryColorP3uiv)(GLenum type, const GLuint *color);
-    void (QOPENGLF_APIENTRYP SecondaryColorP3ui)(GLenum type, GLuint color);
-    void (QOPENGLF_APIENTRYP ColorP4uiv)(GLenum type, const GLuint *color);
-    void (QOPENGLF_APIENTRYP ColorP4ui)(GLenum type, GLuint color);
-    void (QOPENGLF_APIENTRYP ColorP3uiv)(GLenum type, const GLuint *color);
-    void (QOPENGLF_APIENTRYP ColorP3ui)(GLenum type, GLuint color);
-    void (QOPENGLF_APIENTRYP NormalP3uiv)(GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP NormalP3ui)(GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP MultiTexCoordP4uiv)(GLenum texture, GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP MultiTexCoordP4ui)(GLenum texture, GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP MultiTexCoordP3uiv)(GLenum texture, GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP MultiTexCoordP3ui)(GLenum texture, GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP MultiTexCoordP2uiv)(GLenum texture, GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP MultiTexCoordP2ui)(GLenum texture, GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP MultiTexCoordP1uiv)(GLenum texture, GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP MultiTexCoordP1ui)(GLenum texture, GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP TexCoordP4uiv)(GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP TexCoordP4ui)(GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP TexCoordP3uiv)(GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP TexCoordP3ui)(GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP TexCoordP2uiv)(GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP TexCoordP2ui)(GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP TexCoordP1uiv)(GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP TexCoordP1ui)(GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP VertexP4uiv)(GLenum type, const GLuint *value);
-    void (QOPENGLF_APIENTRYP VertexP4ui)(GLenum type, GLuint value);
-    void (QOPENGLF_APIENTRYP VertexP3uiv)(GLenum type, const GLuint *value);
-    void (QOPENGLF_APIENTRYP VertexP3ui)(GLenum type, GLuint value);
-    void (QOPENGLF_APIENTRYP VertexP2uiv)(GLenum type, const GLuint *value);
-    void (QOPENGLF_APIENTRYP VertexP2ui)(GLenum type, GLuint value);
-    void (QOPENGLF_APIENTRYP GetQueryObjectui64v)(GLuint id, GLenum pname, GLuint64 *params);
-    void (QOPENGLF_APIENTRYP GetQueryObjecti64v)(GLuint id, GLenum pname, GLint64 *params);
-    void (QOPENGLF_APIENTRYP QueryCounter)(GLuint id, GLenum target);
-    void (QOPENGLF_APIENTRYP GetSamplerParameterIuiv)(GLuint sampler, GLenum pname, GLuint *params);
-    void (QOPENGLF_APIENTRYP GetSamplerParameterfv)(GLuint sampler, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetSamplerParameterIiv)(GLuint sampler, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetSamplerParameteriv)(GLuint sampler, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP SamplerParameterIuiv)(GLuint sampler, GLenum pname, const GLuint *param);
-    void (QOPENGLF_APIENTRYP SamplerParameterIiv)(GLuint sampler, GLenum pname, const GLint *param);
-    void (QOPENGLF_APIENTRYP SamplerParameterfv)(GLuint sampler, GLenum pname, const GLfloat *param);
-    void (QOPENGLF_APIENTRYP SamplerParameterf)(GLuint sampler, GLenum pname, GLfloat param);
-    void (QOPENGLF_APIENTRYP SamplerParameteriv)(GLuint sampler, GLenum pname, const GLint *param);
-    void (QOPENGLF_APIENTRYP SamplerParameteri)(GLuint sampler, GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP BindSampler)(GLuint unit, GLuint sampler);
-    GLboolean (QOPENGLF_APIENTRYP IsSampler)(GLuint sampler);
-    void (QOPENGLF_APIENTRYP DeleteSamplers)(GLsizei count, const GLuint *samplers);
-    void (QOPENGLF_APIENTRYP GenSamplers)(GLsizei count, GLuint *samplers);
-    GLint (QOPENGLF_APIENTRYP GetFragDataIndex)(GLuint program, const GLchar *name);
-    void (QOPENGLF_APIENTRYP BindFragDataLocationIndexed)(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name);
-    void (QOPENGLF_APIENTRYP VertexAttribDivisor)(GLuint index, GLuint divisor);
+#define QT_OPENGL_3_3_FUNCTIONS(F) \
+    F(void, VertexAttribP4uiv, (GLuint index, GLenum type, GLboolean normalized, const GLuint *value)) \
+    F(void, VertexAttribP4ui, (GLuint index, GLenum type, GLboolean normalized, GLuint value)) \
+    F(void, VertexAttribP3uiv, (GLuint index, GLenum type, GLboolean normalized, const GLuint *value)) \
+    F(void, VertexAttribP3ui, (GLuint index, GLenum type, GLboolean normalized, GLuint value)) \
+    F(void, VertexAttribP2uiv, (GLuint index, GLenum type, GLboolean normalized, const GLuint *value)) \
+    F(void, VertexAttribP2ui, (GLuint index, GLenum type, GLboolean normalized, GLuint value)) \
+    F(void, VertexAttribP1uiv, (GLuint index, GLenum type, GLboolean normalized, const GLuint *value)) \
+    F(void, VertexAttribP1ui, (GLuint index, GLenum type, GLboolean normalized, GLuint value)) \
+    F(void, SecondaryColorP3uiv, (GLenum type, const GLuint *color)) \
+    F(void, SecondaryColorP3ui, (GLenum type, GLuint color)) \
+    F(void, ColorP4uiv, (GLenum type, const GLuint *color)) \
+    F(void, ColorP4ui, (GLenum type, GLuint color)) \
+    F(void, ColorP3uiv, (GLenum type, const GLuint *color)) \
+    F(void, ColorP3ui, (GLenum type, GLuint color)) \
+    F(void, NormalP3uiv, (GLenum type, const GLuint *coords)) \
+    F(void, NormalP3ui, (GLenum type, GLuint coords)) \
+    F(void, MultiTexCoordP4uiv, (GLenum texture, GLenum type, const GLuint *coords)) \
+    F(void, MultiTexCoordP4ui, (GLenum texture, GLenum type, GLuint coords)) \
+    F(void, MultiTexCoordP3uiv, (GLenum texture, GLenum type, const GLuint *coords)) \
+    F(void, MultiTexCoordP3ui, (GLenum texture, GLenum type, GLuint coords)) \
+    F(void, MultiTexCoordP2uiv, (GLenum texture, GLenum type, const GLuint *coords)) \
+    F(void, MultiTexCoordP2ui, (GLenum texture, GLenum type, GLuint coords)) \
+    F(void, MultiTexCoordP1uiv, (GLenum texture, GLenum type, const GLuint *coords)) \
+    F(void, MultiTexCoordP1ui, (GLenum texture, GLenum type, GLuint coords)) \
+    F(void, TexCoordP4uiv, (GLenum type, const GLuint *coords)) \
+    F(void, TexCoordP4ui, (GLenum type, GLuint coords)) \
+    F(void, TexCoordP3uiv, (GLenum type, const GLuint *coords)) \
+    F(void, TexCoordP3ui, (GLenum type, GLuint coords)) \
+    F(void, TexCoordP2uiv, (GLenum type, const GLuint *coords)) \
+    F(void, TexCoordP2ui, (GLenum type, GLuint coords)) \
+    F(void, TexCoordP1uiv, (GLenum type, const GLuint *coords)) \
+    F(void, TexCoordP1ui, (GLenum type, GLuint coords)) \
+    F(void, VertexP4uiv, (GLenum type, const GLuint *value)) \
+    F(void, VertexP4ui, (GLenum type, GLuint value)) \
+    F(void, VertexP3uiv, (GLenum type, const GLuint *value)) \
+    F(void, VertexP3ui, (GLenum type, GLuint value)) \
+    F(void, VertexP2uiv, (GLenum type, const GLuint *value)) \
+    F(void, VertexP2ui, (GLenum type, GLuint value)) \
+    F(void, GetQueryObjectui64v, (GLuint id, GLenum pname, GLuint64 *params)) \
+    F(void, GetQueryObjecti64v, (GLuint id, GLenum pname, GLint64 *params)) \
+    F(void, QueryCounter, (GLuint id, GLenum target)) \
+    F(void, GetSamplerParameterIuiv, (GLuint sampler, GLenum pname, GLuint *params)) \
+    F(void, GetSamplerParameterfv, (GLuint sampler, GLenum pname, GLfloat *params)) \
+    F(void, GetSamplerParameterIiv, (GLuint sampler, GLenum pname, GLint *params)) \
+    F(void, GetSamplerParameteriv, (GLuint sampler, GLenum pname, GLint *params)) \
+    F(void, SamplerParameterIuiv, (GLuint sampler, GLenum pname, const GLuint *param)) \
+    F(void, SamplerParameterIiv, (GLuint sampler, GLenum pname, const GLint *param)) \
+    F(void, SamplerParameterfv, (GLuint sampler, GLenum pname, const GLfloat *param)) \
+    F(void, SamplerParameterf, (GLuint sampler, GLenum pname, GLfloat param)) \
+    F(void, SamplerParameteriv, (GLuint sampler, GLenum pname, const GLint *param)) \
+    F(void, SamplerParameteri, (GLuint sampler, GLenum pname, GLint param)) \
+    F(void, BindSampler, (GLuint unit, GLuint sampler)) \
+    F(GLboolean, IsSampler, (GLuint sampler)) \
+    F(void, DeleteSamplers, (GLsizei count, const GLuint *samplers)) \
+    F(void, GenSamplers, (GLsizei count, GLuint *samplers)) \
+    F(GLint, GetFragDataIndex, (GLuint program, const GLchar *name)) \
+    F(void, BindFragDataLocationIndexed, (GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)) \
+    F(void, VertexAttribDivisor, (GLuint index, GLuint divisor)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_3_3_FUNCTIONS);
 };
 
 class QOpenGLFunctions_4_0_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_4_0_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_4_0_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_4_0_Core; }
 
     // OpenGL 4.0 core functions
-    void (QOPENGLF_APIENTRYP GetQueryIndexediv)(GLenum target, GLuint index, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP EndQueryIndexed)(GLenum target, GLuint index);
-    void (QOPENGLF_APIENTRYP BeginQueryIndexed)(GLenum target, GLuint index, GLuint id);
-    void (QOPENGLF_APIENTRYP DrawTransformFeedbackStream)(GLenum mode, GLuint id, GLuint stream);
-    void (QOPENGLF_APIENTRYP DrawTransformFeedback)(GLenum mode, GLuint id);
-    void (QOPENGLF_APIENTRYP ResumeTransformFeedback)();
-    void (QOPENGLF_APIENTRYP PauseTransformFeedback)();
-    GLboolean (QOPENGLF_APIENTRYP IsTransformFeedback)(GLuint id);
-    void (QOPENGLF_APIENTRYP GenTransformFeedbacks)(GLsizei n, GLuint *ids);
-    void (QOPENGLF_APIENTRYP DeleteTransformFeedbacks)(GLsizei n, const GLuint *ids);
-    void (QOPENGLF_APIENTRYP BindTransformFeedback)(GLenum target, GLuint id);
-    void (QOPENGLF_APIENTRYP PatchParameterfv)(GLenum pname, const GLfloat *values);
-    void (QOPENGLF_APIENTRYP PatchParameteri)(GLenum pname, GLint value);
-    void (QOPENGLF_APIENTRYP GetProgramStageiv)(GLuint program, GLenum shadertype, GLenum pname, GLint *values);
-    void (QOPENGLF_APIENTRYP GetUniformSubroutineuiv)(GLenum shadertype, GLint location, GLuint *params);
-    void (QOPENGLF_APIENTRYP UniformSubroutinesuiv)(GLenum shadertype, GLsizei count, const GLuint *indices);
-    void (QOPENGLF_APIENTRYP GetActiveSubroutineName)(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void (QOPENGLF_APIENTRYP GetActiveSubroutineUniformName)(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name);
-    void (QOPENGLF_APIENTRYP GetActiveSubroutineUniformiv)(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values);
-    GLuint (QOPENGLF_APIENTRYP GetSubroutineIndex)(GLuint program, GLenum shadertype, const GLchar *name);
-    GLint (QOPENGLF_APIENTRYP GetSubroutineUniformLocation)(GLuint program, GLenum shadertype, const GLchar *name);
-    void (QOPENGLF_APIENTRYP GetUniformdv)(GLuint program, GLint location, GLdouble *params);
-    void (QOPENGLF_APIENTRYP UniformMatrix4x3dv)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix4x2dv)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix3x4dv)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix3x2dv)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix2x4dv)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix2x3dv)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix4dv)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix3dv)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP UniformMatrix2dv)(GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP Uniform4dv)(GLint location, GLsizei count, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP Uniform3dv)(GLint location, GLsizei count, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP Uniform2dv)(GLint location, GLsizei count, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP Uniform1dv)(GLint location, GLsizei count, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP Uniform4d)(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void (QOPENGLF_APIENTRYP Uniform3d)(GLint location, GLdouble x, GLdouble y, GLdouble z);
-    void (QOPENGLF_APIENTRYP Uniform2d)(GLint location, GLdouble x, GLdouble y);
-    void (QOPENGLF_APIENTRYP Uniform1d)(GLint location, GLdouble x);
-    void (QOPENGLF_APIENTRYP DrawElementsIndirect)(GLenum mode, GLenum type, const GLvoid *indirect);
-    void (QOPENGLF_APIENTRYP DrawArraysIndirect)(GLenum mode, const GLvoid *indirect);
-    void (QOPENGLF_APIENTRYP BlendFuncSeparatei)(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void (QOPENGLF_APIENTRYP BlendFunci)(GLuint buf, GLenum src, GLenum dst);
-    void (QOPENGLF_APIENTRYP BlendEquationSeparatei)(GLuint buf, GLenum modeRGB, GLenum modeAlpha);
-    void (QOPENGLF_APIENTRYP BlendEquationi)(GLuint buf, GLenum mode);
-    void (QOPENGLF_APIENTRYP MinSampleShading)(GLfloat value);
+#define QT_OPENGL_4_0_FUNCTIONS(F) \
+    F(void, GetQueryIndexediv, (GLenum target, GLuint index, GLenum pname, GLint *params)) \
+    F(void, EndQueryIndexed, (GLenum target, GLuint index)) \
+    F(void, BeginQueryIndexed, (GLenum target, GLuint index, GLuint id)) \
+    F(void, DrawTransformFeedbackStream, (GLenum mode, GLuint id, GLuint stream)) \
+    F(void, DrawTransformFeedback, (GLenum mode, GLuint id)) \
+    F(void, ResumeTransformFeedback, ()) \
+    F(void, PauseTransformFeedback, ()) \
+    F(GLboolean, IsTransformFeedback, (GLuint id)) \
+    F(void, GenTransformFeedbacks, (GLsizei n, GLuint *ids)) \
+    F(void, DeleteTransformFeedbacks, (GLsizei n, const GLuint *ids)) \
+    F(void, BindTransformFeedback, (GLenum target, GLuint id)) \
+    F(void, PatchParameterfv, (GLenum pname, const GLfloat *values)) \
+    F(void, PatchParameteri, (GLenum pname, GLint value)) \
+    F(void, GetProgramStageiv, (GLuint program, GLenum shadertype, GLenum pname, GLint *values)) \
+    F(void, GetUniformSubroutineuiv, (GLenum shadertype, GLint location, GLuint *params)) \
+    F(void, UniformSubroutinesuiv, (GLenum shadertype, GLsizei count, const GLuint *indices)) \
+    F(void, GetActiveSubroutineName, (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)) \
+    F(void, GetActiveSubroutineUniformName, (GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)) \
+    F(void, GetActiveSubroutineUniformiv, (GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)) \
+    F(GLuint, GetSubroutineIndex, (GLuint program, GLenum shadertype, const GLchar *name)) \
+    F(GLint, GetSubroutineUniformLocation, (GLuint program, GLenum shadertype, const GLchar *name)) \
+    F(void, GetUniformdv, (GLuint program, GLint location, GLdouble *params)) \
+    F(void, UniformMatrix4x3dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, UniformMatrix4x2dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, UniformMatrix3x4dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, UniformMatrix3x2dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, UniformMatrix2x4dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, UniformMatrix2x3dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, UniformMatrix4dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, UniformMatrix3dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, UniformMatrix2dv, (GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, Uniform4dv, (GLint location, GLsizei count, const GLdouble *value)) \
+    F(void, Uniform3dv, (GLint location, GLsizei count, const GLdouble *value)) \
+    F(void, Uniform2dv, (GLint location, GLsizei count, const GLdouble *value)) \
+    F(void, Uniform1dv, (GLint location, GLsizei count, const GLdouble *value)) \
+    F(void, Uniform4d, (GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
+    F(void, Uniform3d, (GLint location, GLdouble x, GLdouble y, GLdouble z)) \
+    F(void, Uniform2d, (GLint location, GLdouble x, GLdouble y)) \
+    F(void, Uniform1d, (GLint location, GLdouble x)) \
+    F(void, DrawElementsIndirect, (GLenum mode, GLenum type, const GLvoid *indirect)) \
+    F(void, DrawArraysIndirect, (GLenum mode, const GLvoid *indirect)) \
+    F(void, BlendFuncSeparatei, (GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)) \
+    F(void, BlendFunci, (GLuint buf, GLenum src, GLenum dst)) \
+    F(void, BlendEquationSeparatei, (GLuint buf, GLenum modeRGB, GLenum modeAlpha)) \
+    F(void, BlendEquationi, (GLuint buf, GLenum mode)) \
+    F(void, MinSampleShading, (GLfloat value)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_4_0_FUNCTIONS);
 };
 
 class QOpenGLFunctions_4_1_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_4_1_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_4_1_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_4_1_Core; }
 
     // OpenGL 4.1 core functions
-    void (QOPENGLF_APIENTRYP GetDoublei_v)(GLenum target, GLuint index, GLdouble *data);
-    void (QOPENGLF_APIENTRYP GetFloati_v)(GLenum target, GLuint index, GLfloat *data);
-    void (QOPENGLF_APIENTRYP DepthRangeIndexed)(GLuint index, GLdouble n, GLdouble f);
-    void (QOPENGLF_APIENTRYP DepthRangeArrayv)(GLuint first, GLsizei count, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP ScissorIndexedv)(GLuint index, const GLint *v);
-    void (QOPENGLF_APIENTRYP ScissorIndexed)(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP ScissorArrayv)(GLuint first, GLsizei count, const GLint *v);
-    void (QOPENGLF_APIENTRYP ViewportIndexedfv)(GLuint index, const GLfloat *v);
-    void (QOPENGLF_APIENTRYP ViewportIndexedf)(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h);
-    void (QOPENGLF_APIENTRYP ViewportArrayv)(GLuint first, GLsizei count, const GLfloat *v);
-    void (QOPENGLF_APIENTRYP GetVertexAttribLdv)(GLuint index, GLenum pname, GLdouble *params);
-    void (QOPENGLF_APIENTRYP VertexAttribLPointer)(GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void (QOPENGLF_APIENTRYP VertexAttribL4dv)(GLuint index, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP VertexAttribL3dv)(GLuint index, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP VertexAttribL2dv)(GLuint index, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP VertexAttribL1dv)(GLuint index, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP VertexAttribL4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void (QOPENGLF_APIENTRYP VertexAttribL3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void (QOPENGLF_APIENTRYP VertexAttribL2d)(GLuint index, GLdouble x, GLdouble y);
-    void (QOPENGLF_APIENTRYP VertexAttribL1d)(GLuint index, GLdouble x);
-    void (QOPENGLF_APIENTRYP GetProgramPipelineInfoLog)(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
-    void (QOPENGLF_APIENTRYP ValidateProgramPipeline)(GLuint pipeline);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix4x3dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix3x4dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix4x2dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix2x4dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix3x2dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix2x3dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix4x3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix3x4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix4x2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix2x4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix3x2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix2x3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix4dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix3dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix2dv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix4fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix3fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniformMatrix2fv)(GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform4uiv)(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform4ui)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-    void (QOPENGLF_APIENTRYP ProgramUniform4dv)(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform4d)(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3);
-    void (QOPENGLF_APIENTRYP ProgramUniform4fv)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform4f)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-    void (QOPENGLF_APIENTRYP ProgramUniform4iv)(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform4i)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3);
-    void (QOPENGLF_APIENTRYP ProgramUniform3uiv)(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform3ui)(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2);
-    void (QOPENGLF_APIENTRYP ProgramUniform3dv)(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform3d)(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2);
-    void (QOPENGLF_APIENTRYP ProgramUniform3fv)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform3f)(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2);
-    void (QOPENGLF_APIENTRYP ProgramUniform3iv)(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform3i)(GLuint program, GLint location, GLint v0, GLint v1, GLint v2);
-    void (QOPENGLF_APIENTRYP ProgramUniform2uiv)(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform2ui)(GLuint program, GLint location, GLuint v0, GLuint v1);
-    void (QOPENGLF_APIENTRYP ProgramUniform2dv)(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform2d)(GLuint program, GLint location, GLdouble v0, GLdouble v1);
-    void (QOPENGLF_APIENTRYP ProgramUniform2fv)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform2f)(GLuint program, GLint location, GLfloat v0, GLfloat v1);
-    void (QOPENGLF_APIENTRYP ProgramUniform2iv)(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform2i)(GLuint program, GLint location, GLint v0, GLint v1);
-    void (QOPENGLF_APIENTRYP ProgramUniform1uiv)(GLuint program, GLint location, GLsizei count, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform1ui)(GLuint program, GLint location, GLuint v0);
-    void (QOPENGLF_APIENTRYP ProgramUniform1dv)(GLuint program, GLint location, GLsizei count, const GLdouble *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform1d)(GLuint program, GLint location, GLdouble v0);
-    void (QOPENGLF_APIENTRYP ProgramUniform1fv)(GLuint program, GLint location, GLsizei count, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform1f)(GLuint program, GLint location, GLfloat v0);
-    void (QOPENGLF_APIENTRYP ProgramUniform1iv)(GLuint program, GLint location, GLsizei count, const GLint *value);
-    void (QOPENGLF_APIENTRYP ProgramUniform1i)(GLuint program, GLint location, GLint v0);
-    void (QOPENGLF_APIENTRYP GetProgramPipelineiv)(GLuint pipeline, GLenum pname, GLint *params);
-    GLboolean (QOPENGLF_APIENTRYP IsProgramPipeline)(GLuint pipeline);
-    void (QOPENGLF_APIENTRYP GenProgramPipelines)(GLsizei n, GLuint *pipelines);
-    void (QOPENGLF_APIENTRYP DeleteProgramPipelines)(GLsizei n, const GLuint *pipelines);
-    void (QOPENGLF_APIENTRYP BindProgramPipeline)(GLuint pipeline);
-    GLuint (QOPENGLF_APIENTRYP CreateShaderProgramv)(GLenum type, GLsizei count, const GLchar* const *strings);
-    void (QOPENGLF_APIENTRYP ActiveShaderProgram)(GLuint pipeline, GLuint program);
-    void (QOPENGLF_APIENTRYP UseProgramStages)(GLuint pipeline, GLbitfield stages, GLuint program);
-    void (QOPENGLF_APIENTRYP ProgramParameteri)(GLuint program, GLenum pname, GLint value);
-    void (QOPENGLF_APIENTRYP ProgramBinary)(GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length);
-    void (QOPENGLF_APIENTRYP GetProgramBinary)(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary);
-    void (QOPENGLF_APIENTRYP ClearDepthf)(GLfloat dd);
-    void (QOPENGLF_APIENTRYP DepthRangef)(GLfloat n, GLfloat f);
-    void (QOPENGLF_APIENTRYP GetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision);
-    void (QOPENGLF_APIENTRYP ShaderBinary)(GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length);
-    void (QOPENGLF_APIENTRYP ReleaseShaderCompiler)();
+#define QT_OPENGL_4_1_FUNCTIONS(F) \
+    F(void, GetDoublei_v, (GLenum target, GLuint index, GLdouble *data)) \
+    F(void, GetFloati_v,(GLenum target, GLuint index, GLfloat *data)) \
+    F(void, DepthRangeIndexed, (GLuint index, GLdouble n, GLdouble f)) \
+    F(void, DepthRangeArrayv, (GLuint first, GLsizei count, const GLdouble *v)) \
+    F(void, ScissorIndexedv, (GLuint index, const GLint *v)) \
+    F(void, ScissorIndexed, (GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)) \
+    F(void, ScissorArrayv, (GLuint first, GLsizei count, const GLint *v)) \
+    F(void, ViewportIndexedfv, (GLuint index, const GLfloat *v)) \
+    F(void, ViewportIndexedf, (GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)) \
+    F(void, ViewportArrayv, (GLuint first, GLsizei count, const GLfloat *v)) \
+    F(void, GetVertexAttribLdv, (GLuint index, GLenum pname, GLdouble *params)) \
+    F(void, VertexAttribLPointer, (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)) \
+    F(void, VertexAttribL4dv, (GLuint index, const GLdouble *v)) \
+    F(void, VertexAttribL3dv, (GLuint index, const GLdouble *v)) \
+    F(void, VertexAttribL2dv, (GLuint index, const GLdouble *v)) \
+    F(void, VertexAttribL1dv, (GLuint index, const GLdouble *v)) \
+    F(void, VertexAttribL4d, (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
+    F(void, VertexAttribL3d, (GLuint index, GLdouble x, GLdouble y, GLdouble z)) \
+    F(void, VertexAttribL2d, (GLuint index, GLdouble x, GLdouble y)) \
+    F(void, VertexAttribL1d, (GLuint index, GLdouble x)) \
+    F(void, GetProgramPipelineInfoLog, (GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)) \
+    F(void, ValidateProgramPipeline, (GLuint pipeline)) \
+    F(void, ProgramUniformMatrix4x3dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, ProgramUniformMatrix3x4dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, ProgramUniformMatrix4x2dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, ProgramUniformMatrix2x4dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, ProgramUniformMatrix3x2dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, ProgramUniformMatrix2x3dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, ProgramUniformMatrix4x3fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix3x4fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix4x2fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix2x4fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix3x2fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix2x3fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix4dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, ProgramUniformMatrix3dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, ProgramUniformMatrix2dv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLdouble *value)) \
+    F(void, ProgramUniformMatrix4fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix3fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniformMatrix2fv, (GLuint program, GLint location, GLsizei count, GLboolean transpose, const GLfloat *value)) \
+    F(void, ProgramUniform4uiv, (GLuint program, GLint location, GLsizei count, const GLuint *value)) \
+    F(void, ProgramUniform4ui, (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)) \
+    F(void, ProgramUniform4dv, (GLuint program, GLint location, GLsizei count, const GLdouble *value)) \
+    F(void, ProgramUniform4d, (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)) \
+    F(void, ProgramUniform4fv, (GLuint program, GLint location, GLsizei count, const GLfloat *value)) \
+    F(void, ProgramUniform4f, (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)) \
+    F(void, ProgramUniform4iv, (GLuint program, GLint location, GLsizei count, const GLint *value)) \
+    F(void, ProgramUniform4i, (GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)) \
+    F(void, ProgramUniform3uiv, (GLuint program, GLint location, GLsizei count, const GLuint *value)) \
+    F(void, ProgramUniform3ui, (GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)) \
+    F(void, ProgramUniform3dv, (GLuint program, GLint location, GLsizei count, const GLdouble *value)) \
+    F(void, ProgramUniform3d, (GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)) \
+    F(void, ProgramUniform3fv, (GLuint program, GLint location, GLsizei count, const GLfloat *value)) \
+    F(void, ProgramUniform3f, (GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)) \
+    F(void, ProgramUniform3iv, (GLuint program, GLint location, GLsizei count, const GLint *value)) \
+    F(void, ProgramUniform3i, (GLuint program, GLint location, GLint v0, GLint v1, GLint v2)) \
+    F(void, ProgramUniform2uiv, (GLuint program, GLint location, GLsizei count, const GLuint *value)) \
+    F(void, ProgramUniform2ui, (GLuint program, GLint location, GLuint v0, GLuint v1)) \
+    F(void, ProgramUniform2dv, (GLuint program, GLint location, GLsizei count, const GLdouble *value)) \
+    F(void, ProgramUniform2d, (GLuint program, GLint location, GLdouble v0, GLdouble v1)) \
+    F(void, ProgramUniform2fv, (GLuint program, GLint location, GLsizei count, const GLfloat *value)) \
+    F(void, ProgramUniform2f, (GLuint program, GLint location, GLfloat v0, GLfloat v1)) \
+    F(void, ProgramUniform2iv, (GLuint program, GLint location, GLsizei count, const GLint *value)) \
+    F(void, ProgramUniform2i, (GLuint program, GLint location, GLint v0, GLint v1)) \
+    F(void, ProgramUniform1uiv, (GLuint program, GLint location, GLsizei count, const GLuint *value)) \
+    F(void, ProgramUniform1ui, (GLuint program, GLint location, GLuint v0)) \
+    F(void, ProgramUniform1dv, (GLuint program, GLint location, GLsizei count, const GLdouble *value)) \
+    F(void, ProgramUniform1d, (GLuint program, GLint location, GLdouble v0)) \
+    F(void, ProgramUniform1fv, (GLuint program, GLint location, GLsizei count, const GLfloat *value)) \
+    F(void, ProgramUniform1f, (GLuint program, GLint location, GLfloat v0)) \
+    F(void, ProgramUniform1iv, (GLuint program, GLint location, GLsizei count, const GLint *value)) \
+    F(void, ProgramUniform1i, (GLuint program, GLint location, GLint v0)) \
+    F(void, GetProgramPipelineiv, (GLuint pipeline, GLenum pname, GLint *params)) \
+    F(GLboolean, IsProgramPipeline, (GLuint pipeline)) \
+    F(void, GenProgramPipelines, (GLsizei n, GLuint *pipelines)) \
+    F(void, DeleteProgramPipelines, (GLsizei n, const GLuint *pipelines)) \
+    F(void, BindProgramPipeline, (GLuint pipeline)) \
+    F(GLuint, CreateShaderProgramv, (GLenum type, GLsizei count, const GLchar* const *strings)) \
+    F(void, ActiveShaderProgram, (GLuint pipeline, GLuint program)) \
+    F(void, UseProgramStages, (GLuint pipeline, GLbitfield stages, GLuint program)) \
+    F(void, ProgramParameteri, (GLuint program, GLenum pname, GLint value)) \
+    F(void, ProgramBinary, (GLuint program, GLenum binaryFormat, const GLvoid *binary, GLsizei length)) \
+    F(void, GetProgramBinary, (GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, GLvoid *binary)) \
+    F(void, ClearDepthf, (GLfloat dd)) \
+    F(void, DepthRangef, (GLfloat n, GLfloat f)) \
+    F(void, GetShaderPrecisionFormat, (GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)) \
+    F(void, ShaderBinary, (GLsizei count, const GLuint *shaders, GLenum binaryformat, const GLvoid *binary, GLsizei length)) \
+    F(void, ReleaseShaderCompiler, ()) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_4_1_FUNCTIONS);
 };
 
 class QOpenGLFunctions_4_2_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_4_2_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_4_2_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_4_2_Core; }
 
     // OpenGL 4.2 core functions
-    void (QOPENGLF_APIENTRYP TexStorage3D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-    void (QOPENGLF_APIENTRYP TexStorage2D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP TexStorage1D)(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width);
-    void (QOPENGLF_APIENTRYP MemoryBarrier)(GLbitfield barriers);
-    void (QOPENGLF_APIENTRYP BindImageTexture)(GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format);
-    void (QOPENGLF_APIENTRYP GetActiveAtomicCounterBufferiv)(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetInternalformativ)(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params);
-    void (QOPENGLF_APIENTRYP DrawTransformFeedbackStreamInstanced)(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount);
-    void (QOPENGLF_APIENTRYP DrawTransformFeedbackInstanced)(GLenum mode, GLuint id, GLsizei instancecount);
-    void (QOPENGLF_APIENTRYP DrawElementsInstancedBaseVertexBaseInstance)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance);
-    void (QOPENGLF_APIENTRYP DrawElementsInstancedBaseInstance)(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance);
-    void (QOPENGLF_APIENTRYP DrawArraysInstancedBaseInstance)(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance);
+#define QT_OPENGL_4_2_FUNCTIONS(F) \
+    F(void, TexStorage3D, (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)) \
+    F(void, TexStorage2D, (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)) \
+    F(void, TexStorage1D, (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)) \
+    F(void, MemoryBarrier, (GLbitfield barriers)) \
+    F(void, BindImageTexture, (GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format)) \
+    F(void, GetActiveAtomicCounterBufferiv, (GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)) \
+    F(void, GetInternalformativ, (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)) \
+    F(void, DrawTransformFeedbackStreamInstanced, (GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)) \
+    F(void, DrawTransformFeedbackInstanced, (GLenum mode, GLuint id, GLsizei instancecount)) \
+    F(void, DrawElementsInstancedBaseVertexBaseInstance, (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)) \
+    F(void, DrawElementsInstancedBaseInstance, (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)) \
+    F(void, DrawArraysInstancedBaseInstance, (GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_4_2_FUNCTIONS);
 };
 
 class QOpenGLFunctions_4_3_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_4_3_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_4_3_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_4_3_Core; }
 
     // OpenGL 4.3 core functions
-    void (QOPENGLF_APIENTRYP TexStorage3DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void (QOPENGLF_APIENTRYP TexStorage2DMultisample)(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void (QOPENGLF_APIENTRYP TexBufferRange)(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size);
-    void (QOPENGLF_APIENTRYP ShaderStorageBlockBinding)(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding);
-    GLint (QOPENGLF_APIENTRYP GetProgramResourceLocationIndex)(GLuint program, GLenum programInterface, const GLchar *name);
-    GLint (QOPENGLF_APIENTRYP GetProgramResourceLocation)(GLuint program, GLenum programInterface, const GLchar *name);
-    void (QOPENGLF_APIENTRYP GetProgramResourceiv)(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params);
-    void (QOPENGLF_APIENTRYP GetProgramResourceName)(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name);
-    GLuint (QOPENGLF_APIENTRYP GetProgramResourceIndex)(GLuint program, GLenum programInterface, const GLchar *name);
-    void (QOPENGLF_APIENTRYP GetProgramInterfaceiv)(GLuint program, GLenum programInterface, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP MultiDrawElementsIndirect)(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride);
-    void (QOPENGLF_APIENTRYP MultiDrawArraysIndirect)(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride);
-    void (QOPENGLF_APIENTRYP InvalidateSubFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP InvalidateFramebuffer)(GLenum target, GLsizei numAttachments, const GLenum *attachments);
-    void (QOPENGLF_APIENTRYP InvalidateBufferData)(GLuint buffer);
-    void (QOPENGLF_APIENTRYP InvalidateBufferSubData)(GLuint buffer, GLintptr offset, GLsizeiptr length);
-    void (QOPENGLF_APIENTRYP InvalidateTexImage)(GLuint texture, GLint level);
-    void (QOPENGLF_APIENTRYP InvalidateTexSubImage)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth);
-    void (QOPENGLF_APIENTRYP GetInternalformati64v)(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params);
-    void (QOPENGLF_APIENTRYP GetFramebufferParameteriv)(GLenum target, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP FramebufferParameteri)(GLenum target, GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP VertexBindingDivisor)(GLuint bindingindex, GLuint divisor);
-    void (QOPENGLF_APIENTRYP VertexAttribBinding)(GLuint attribindex, GLuint bindingindex);
-    void (QOPENGLF_APIENTRYP VertexAttribLFormat)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void (QOPENGLF_APIENTRYP VertexAttribIFormat)(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void (QOPENGLF_APIENTRYP VertexAttribFormat)(GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
-    void (QOPENGLF_APIENTRYP BindVertexBuffer)(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
-    void (QOPENGLF_APIENTRYP TextureView)(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers);
-    void (QOPENGLF_APIENTRYP CopyImageSubData)(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth);
-    void (QOPENGLF_APIENTRYP DispatchComputeIndirect)(GLintptr indirect);
-    void (QOPENGLF_APIENTRYP DispatchCompute)(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z);
-    void (QOPENGLF_APIENTRYP ClearBufferSubData)(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data);
-    void (QOPENGLF_APIENTRYP ClearBufferData)(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data);
-    void (QOPENGLF_APIENTRYP GetObjectPtrLabel)(const GLvoid *ptr, GLsizei bufSize, GLsizei *length, GLchar *label);
-    void (QOPENGLF_APIENTRYP ObjectPtrLabel)(const GLvoid *ptr, GLsizei length, const GLchar *label);
-    void (QOPENGLF_APIENTRYP GetObjectLabel)(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label);
-    void (QOPENGLF_APIENTRYP ObjectLabel)(GLenum identifier, GLuint name, GLsizei length, const GLchar *label);
-    void (QOPENGLF_APIENTRYP PopDebugGroup)();
-    void (QOPENGLF_APIENTRYP PushDebugGroup)(GLenum source, GLuint id, GLsizei length, const GLchar *message);
-    GLuint (QOPENGLF_APIENTRYP GetDebugMessageLog)(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog);
-    void (QOPENGLF_APIENTRYP DebugMessageCallback)(GLDEBUGPROC callback, const GLvoid *userParam);
-    void (QOPENGLF_APIENTRYP DebugMessageInsert)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf);
-    void (QOPENGLF_APIENTRYP DebugMessageControl)(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled);
+#define QT_OPENGL_4_3_FUNCTIONS(F) \
+    F(void, TexStorage3DMultisample, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)) \
+    F(void, TexStorage2DMultisample, (GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)) \
+    F(void, TexBufferRange, (GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)) \
+    F(void, ShaderStorageBlockBinding, (GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)) \
+    F(GLint, GetProgramResourceLocationIndex, (GLuint program, GLenum programInterface, const GLchar *name)) \
+    F(GLint, GetProgramResourceLocation, (GLuint program, GLenum programInterface, const GLchar *name)) \
+    F(void, GetProgramResourceiv, (GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)) \
+    F(void, GetProgramResourceName, (GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)) \
+    F(GLuint, GetProgramResourceIndex, (GLuint program, GLenum programInterface, const GLchar *name)) \
+    F(void, GetProgramInterfaceiv, (GLuint program, GLenum programInterface, GLenum pname, GLint *params)) \
+    F(void, MultiDrawElementsIndirect, (GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)) \
+    F(void, MultiDrawArraysIndirect, (GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)) \
+    F(void, InvalidateSubFramebuffer, (GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)) \
+    F(void, InvalidateFramebuffer, (GLenum target, GLsizei numAttachments, const GLenum *attachments)) \
+    F(void, InvalidateBufferData, (GLuint buffer)) \
+    F(void, InvalidateBufferSubData, (GLuint buffer, GLintptr offset, GLsizeiptr length)) \
+    F(void, InvalidateTexImage, (GLuint texture, GLint level)) \
+    F(void, InvalidateTexSubImage, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)) \
+    F(void, GetInternalformati64v, (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)) \
+    F(void, GetFramebufferParameteriv, (GLenum target, GLenum pname, GLint *params)) \
+    F(void, FramebufferParameteri, (GLenum target, GLenum pname, GLint param)) \
+    F(void, VertexBindingDivisor, (GLuint bindingindex, GLuint divisor)) \
+    F(void, VertexAttribBinding, (GLuint attribindex, GLuint bindingindex)) \
+    F(void, VertexAttribLFormat, (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)) \
+    F(void, VertexAttribIFormat, (GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)) \
+    F(void, VertexAttribFormat, (GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)) \
+    F(void, BindVertexBuffer, (GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)) \
+    F(void, TextureView, (GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)) \
+    F(void, CopyImageSubData, (GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)) \
+    F(void, DispatchComputeIndirect, (GLintptr indirect)) \
+    F(void, DispatchCompute, (GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)) \
+    F(void, ClearBufferSubData, (GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)) \
+    F(void, ClearBufferData, (GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)) \
+    F(void, GetObjectPtrLabel, (const GLvoid *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)) \
+    F(void, ObjectPtrLabel, (const GLvoid *ptr, GLsizei length, const GLchar *label)) \
+    F(void, GetObjectLabel, (GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)) \
+    F(void, ObjectLabel, (GLenum identifier, GLuint name, GLsizei length, const GLchar *label)) \
+    F(void, PopDebugGroup, ()) \
+    F(void, PushDebugGroup, (GLenum source, GLuint id, GLsizei length, const GLchar *message)) \
+    F(GLuint, GetDebugMessageLog, (GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)) \
+    F(void, DebugMessageCallback, (GLDEBUGPROC callback, const GLvoid *userParam)) \
+    F(void, DebugMessageInsert, (GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)) \
+    F(void, DebugMessageControl, (GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean enabled)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_4_3_FUNCTIONS);
 };
 
 class QOpenGLFunctions_4_4_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_4_4_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_4_4_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_4_4_Core; }
 
     // OpenGL 4.4 core functions
-    void (QOPENGLF_APIENTRYP BindVertexBuffers)(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides);
-    void (QOPENGLF_APIENTRYP BindImageTextures)(GLuint first, GLsizei count, const GLuint *textures);
-    void (QOPENGLF_APIENTRYP BindSamplers)(GLuint first, GLsizei count, const GLuint *samplers);
-    void (QOPENGLF_APIENTRYP BindTextures)(GLuint first, GLsizei count, const GLuint *textures);
-    void (QOPENGLF_APIENTRYP BindBuffersRange)(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes);
-    void (QOPENGLF_APIENTRYP BindBuffersBase)(GLenum target, GLuint first, GLsizei count, const GLuint *buffers);
-    void (QOPENGLF_APIENTRYP ClearTexSubImage)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data);
-    void (QOPENGLF_APIENTRYP ClearTexImage)(GLuint texture, GLint level, GLenum format, GLenum type, const void *data);
-    void (QOPENGLF_APIENTRYP BufferStorage)(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags);
+#define QT_OPENGL_4_4_FUNCTIONS(F) \
+    F(void, BindVertexBuffers, (GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)) \
+    F(void, BindImageTextures, (GLuint first, GLsizei count, const GLuint *textures)) \
+    F(void, BindSamplers, (GLuint first, GLsizei count, const GLuint *samplers)) \
+    F(void, BindTextures, (GLuint first, GLsizei count, const GLuint *textures)) \
+    F(void, BindBuffersRange, (GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes)) \
+    F(void, BindBuffersBase, (GLenum target, GLuint first, GLsizei count, const GLuint *buffers)) \
+    F(void, ClearTexSubImage, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data)) \
+    F(void, ClearTexImage, (GLuint texture, GLint level, GLenum format, GLenum type, const void *data)) \
+    F(void, BufferStorage, (GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_4_4_FUNCTIONS);
 };
 
 class QOpenGLFunctions_4_5_CoreBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_4_5_CoreBackend(QOpenGLContext *context);
+    QOpenGLFunctions_4_5_CoreBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_4_5_Core; }
 
     // OpenGL 4.5 core functions
-    void (QOPENGLF_APIENTRYP TextureBarrier)();
-    void (QOPENGLF_APIENTRYP ReadnPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data);
-    void (QOPENGLF_APIENTRYP GetnUniformuiv)(GLuint program, GLint location, GLsizei bufSize, GLuint *params);
-    void (QOPENGLF_APIENTRYP GetnUniformiv)(GLuint program, GLint location, GLsizei bufSize, GLint *params);
-    void (QOPENGLF_APIENTRYP GetnUniformfv)(GLuint program, GLint location, GLsizei bufSize, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetnUniformdv)(GLuint program, GLint location, GLsizei bufSize, GLdouble *params);
-    void (QOPENGLF_APIENTRYP GetnTexImage)(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
-    void (QOPENGLF_APIENTRYP GetnCompressedTexImage)(GLenum target, GLint lod, GLsizei bufSize, void *pixels);
-    GLenum (QOPENGLF_APIENTRYP GetGraphicsResetStatus)();
-    void (QOPENGLF_APIENTRYP GetCompressedTextureSubImage)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels);
-    void (QOPENGLF_APIENTRYP GetTextureSubImage)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
-    void (QOPENGLF_APIENTRYP MemoryBarrierByRegion)(GLbitfield barriers);
-    void (QOPENGLF_APIENTRYP CreateQueries)(GLenum target, GLsizei n, GLuint *ids);
-    void (QOPENGLF_APIENTRYP CreateProgramPipelines)(GLsizei n, GLuint *pipelines);
-    void (QOPENGLF_APIENTRYP CreateSamplers)(GLsizei n, GLuint *samplers);
-    void (QOPENGLF_APIENTRYP GetVertexArrayIndexed64iv)(GLuint vaobj, GLuint index, GLenum pname, GLint64 *param);
-    void (QOPENGLF_APIENTRYP GetVertexArrayIndexediv)(GLuint vaobj, GLuint index, GLenum pname, GLint *param);
-    void (QOPENGLF_APIENTRYP GetVertexArrayiv)(GLuint vaobj, GLenum pname, GLint *param);
-    void (QOPENGLF_APIENTRYP VertexArrayBindingDivisor)(GLuint vaobj, GLuint bindingindex, GLuint divisor);
-    void (QOPENGLF_APIENTRYP VertexArrayAttribLFormat)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void (QOPENGLF_APIENTRYP VertexArrayAttribIFormat)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset);
-    void (QOPENGLF_APIENTRYP VertexArrayAttribFormat)(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset);
-    void (QOPENGLF_APIENTRYP VertexArrayAttribBinding)(GLuint vaobj, GLuint attribindex, GLuint bindingindex);
-    void (QOPENGLF_APIENTRYP VertexArrayVertexBuffers)(GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides);
-    void (QOPENGLF_APIENTRYP VertexArrayVertexBuffer)(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride);
-    void (QOPENGLF_APIENTRYP VertexArrayElementBuffer)(GLuint vaobj, GLuint buffer);
-    void (QOPENGLF_APIENTRYP EnableVertexArrayAttrib)(GLuint vaobj, GLuint index);
-    void (QOPENGLF_APIENTRYP DisableVertexArrayAttrib)(GLuint vaobj, GLuint index);
-    void (QOPENGLF_APIENTRYP CreateVertexArrays)(GLsizei n, GLuint *arrays);
-    void (QOPENGLF_APIENTRYP GetTextureParameteriv)(GLuint texture, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetTextureParameterIuiv)(GLuint texture, GLenum pname, GLuint *params);
-    void (QOPENGLF_APIENTRYP GetTextureParameterIiv)(GLuint texture, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetTextureParameterfv)(GLuint texture, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetTextureLevelParameteriv)(GLuint texture, GLint level, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetTextureLevelParameterfv)(GLuint texture, GLint level, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetCompressedTextureImage)(GLuint texture, GLint level, GLsizei bufSize, void *pixels);
-    void (QOPENGLF_APIENTRYP GetTextureImage)(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels);
-    void (QOPENGLF_APIENTRYP BindTextureUnit)(GLuint unit, GLuint texture);
-    void (QOPENGLF_APIENTRYP GenerateTextureMipmap)(GLuint texture);
-    void (QOPENGLF_APIENTRYP TextureParameteriv)(GLuint texture, GLenum pname, const GLint *param);
-    void (QOPENGLF_APIENTRYP TextureParameterIuiv)(GLuint texture, GLenum pname, const GLuint *params);
-    void (QOPENGLF_APIENTRYP TextureParameterIiv)(GLuint texture, GLenum pname, const GLint *params);
-    void (QOPENGLF_APIENTRYP TextureParameteri)(GLuint texture, GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP TextureParameterfv)(GLuint texture, GLenum pname, const GLfloat *param);
-    void (QOPENGLF_APIENTRYP TextureParameterf)(GLuint texture, GLenum pname, GLfloat param);
-    void (QOPENGLF_APIENTRYP CopyTextureSubImage3D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP CopyTextureSubImage2D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP CopyTextureSubImage1D)(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width);
-    void (QOPENGLF_APIENTRYP CompressedTextureSubImage3D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data);
-    void (QOPENGLF_APIENTRYP CompressedTextureSubImage2D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data);
-    void (QOPENGLF_APIENTRYP CompressedTextureSubImage1D)(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data);
-    void (QOPENGLF_APIENTRYP TextureSubImage3D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels);
-    void (QOPENGLF_APIENTRYP TextureSubImage2D)(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels);
-    void (QOPENGLF_APIENTRYP TextureSubImage1D)(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels);
-    void (QOPENGLF_APIENTRYP TextureStorage3DMultisample)(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations);
-    void (QOPENGLF_APIENTRYP TextureStorage2DMultisample)(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations);
-    void (QOPENGLF_APIENTRYP TextureStorage3D)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth);
-    void (QOPENGLF_APIENTRYP TextureStorage2D)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP TextureStorage1D)(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width);
-    void (QOPENGLF_APIENTRYP TextureBufferRange)(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizei size);
-    void (QOPENGLF_APIENTRYP TextureBuffer)(GLuint texture, GLenum internalformat, GLuint buffer);
-    void (QOPENGLF_APIENTRYP CreateTextures)(GLenum target, GLsizei n, GLuint *textures);
-    void (QOPENGLF_APIENTRYP GetNamedRenderbufferParameteriv)(GLuint renderbuffer, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP NamedRenderbufferStorageMultisample)(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP NamedRenderbufferStorage)(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP CreateRenderbuffers)(GLsizei n, GLuint *renderbuffers);
-    void (QOPENGLF_APIENTRYP GetNamedFramebufferAttachmentParameteriv)(GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetNamedFramebufferParameteriv)(GLuint framebuffer, GLenum pname, GLint *param);
-    GLenum (QOPENGLF_APIENTRYP CheckNamedFramebufferStatus)(GLuint framebuffer, GLenum target);
-    void (QOPENGLF_APIENTRYP BlitNamedFramebuffer)(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter);
-    void (QOPENGLF_APIENTRYP ClearNamedFramebufferfi)(GLuint framebuffer, GLenum buffer, GLfloat depth, GLint stencil);
-    void (QOPENGLF_APIENTRYP ClearNamedFramebufferfv)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value);
-    void (QOPENGLF_APIENTRYP ClearNamedFramebufferuiv)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value);
-    void (QOPENGLF_APIENTRYP ClearNamedFramebufferiv)(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value);
-    void (QOPENGLF_APIENTRYP InvalidateNamedFramebufferSubData)(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP InvalidateNamedFramebufferData)(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments);
-    void (QOPENGLF_APIENTRYP NamedFramebufferReadBuffer)(GLuint framebuffer, GLenum src);
-    void (QOPENGLF_APIENTRYP NamedFramebufferDrawBuffers)(GLuint framebuffer, GLsizei n, const GLenum *bufs);
-    void (QOPENGLF_APIENTRYP NamedFramebufferDrawBuffer)(GLuint framebuffer, GLenum buf);
-    void (QOPENGLF_APIENTRYP NamedFramebufferTextureLayer)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer);
-    void (QOPENGLF_APIENTRYP NamedFramebufferTexture)(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level);
-    void (QOPENGLF_APIENTRYP NamedFramebufferParameteri)(GLuint framebuffer, GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP NamedFramebufferRenderbuffer)(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void (QOPENGLF_APIENTRYP CreateFramebuffers)(GLsizei n, GLuint *framebuffers);
-    void (QOPENGLF_APIENTRYP GetNamedBufferSubData)(GLuint buffer, GLintptr offset, GLsizei size, void *data);
-    void (QOPENGLF_APIENTRYP GetNamedBufferPointerv)(GLuint buffer, GLenum pname, GLvoid* *params);
-    void (QOPENGLF_APIENTRYP GetNamedBufferParameteri64v)(GLuint buffer, GLenum pname, GLint64 *params);
-    void (QOPENGLF_APIENTRYP GetNamedBufferParameteriv)(GLuint buffer, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP FlushMappedNamedBufferRange)(GLuint buffer, GLintptr offset, GLsizei length);
-    GLboolean (QOPENGLF_APIENTRYP UnmapNamedBuffer)(GLuint buffer);
-    GLvoid* (QOPENGLF_APIENTRYP MapNamedBufferRange)(GLuint buffer, GLintptr offset, GLsizei length, GLbitfield access);
-    GLvoid* (QOPENGLF_APIENTRYP MapNamedBuffer)(GLuint buffer, GLenum access);
-    void (QOPENGLF_APIENTRYP ClearNamedBufferSubData)(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizei size, GLenum format, GLenum type, const void *data);
-    void (QOPENGLF_APIENTRYP ClearNamedBufferData)(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data);
-    void (QOPENGLF_APIENTRYP CopyNamedBufferSubData)(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizei size);
-    void (QOPENGLF_APIENTRYP NamedBufferSubData)(GLuint buffer, GLintptr offset, GLsizei size, const void *data);
-    void (QOPENGLF_APIENTRYP NamedBufferData)(GLuint buffer, GLsizei size, const void *data, GLenum usage);
-    void (QOPENGLF_APIENTRYP NamedBufferStorage)(GLuint buffer, GLsizei size, const void *data, GLbitfield flags);
-    void (QOPENGLF_APIENTRYP CreateBuffers)(GLsizei n, GLuint *buffers);
-    void (QOPENGLF_APIENTRYP GetTransformFeedbacki64_v)(GLuint xfb, GLenum pname, GLuint index, GLint64 *param);
-    void (QOPENGLF_APIENTRYP GetTransformFeedbacki_v)(GLuint xfb, GLenum pname, GLuint index, GLint *param);
-    void (QOPENGLF_APIENTRYP GetTransformFeedbackiv)(GLuint xfb, GLenum pname, GLint *param);
-    void (QOPENGLF_APIENTRYP TransformFeedbackBufferRange)(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizei size);
-    void (QOPENGLF_APIENTRYP TransformFeedbackBufferBase)(GLuint xfb, GLuint index, GLuint buffer);
-    void (QOPENGLF_APIENTRYP CreateTransformFeedbacks)(GLsizei n, GLuint *ids);
-    void (QOPENGLF_APIENTRYP ClipControl)(GLenum origin, GLenum depth);
+#define QT_OPENGL_4_5_FUNCTIONS(F) \
+    F(void, TextureBarrier, ()) \
+    F(void, ReadnPixels, (GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)) \
+    F(void, GetnUniformuiv, (GLuint program, GLint location, GLsizei bufSize, GLuint *params)) \
+    F(void, GetnUniformiv, (GLuint program, GLint location, GLsizei bufSize, GLint *params)) \
+    F(void, GetnUniformfv, (GLuint program, GLint location, GLsizei bufSize, GLfloat *params)) \
+    F(void, GetnUniformdv, (GLuint program, GLint location, GLsizei bufSize, GLdouble *params)) \
+    F(void, GetnTexImage, (GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)) \
+    F(void, GetnCompressedTexImage, (GLenum target, GLint lod, GLsizei bufSize, void *pixels)) \
+    F(GLenum, GetGraphicsResetStatus, ()) \
+    F(void, GetCompressedTextureSubImage, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels)) \
+    F(void, GetTextureSubImage, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels)) \
+    F(void, MemoryBarrierByRegion, (GLbitfield barriers)) \
+    F(void, CreateQueries, (GLenum target, GLsizei n, GLuint *ids)) \
+    F(void, CreateProgramPipelines, (GLsizei n, GLuint *pipelines)) \
+    F(void, CreateSamplers, (GLsizei n, GLuint *samplers)) \
+    F(void, GetVertexArrayIndexed64iv, (GLuint vaobj, GLuint index, GLenum pname, GLint64 *param)) \
+    F(void, GetVertexArrayIndexediv, (GLuint vaobj, GLuint index, GLenum pname, GLint *param)) \
+    F(void, GetVertexArrayiv, (GLuint vaobj, GLenum pname, GLint *param)) \
+    F(void, VertexArrayBindingDivisor, (GLuint vaobj, GLuint bindingindex, GLuint divisor)) \
+    F(void, VertexArrayAttribLFormat, (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)) \
+    F(void, VertexArrayAttribIFormat, (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)) \
+    F(void, VertexArrayAttribFormat, (GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean normalized, GLuint relativeoffset)) \
+    F(void, VertexArrayAttribBinding, (GLuint vaobj, GLuint attribindex, GLuint bindingindex)) \
+    F(void, VertexArrayVertexBuffers, (GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)) \
+    F(void, VertexArrayVertexBuffer, (GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)) \
+    F(void, VertexArrayElementBuffer, (GLuint vaobj, GLuint buffer)) \
+    F(void, EnableVertexArrayAttrib, (GLuint vaobj, GLuint index)) \
+    F(void, DisableVertexArrayAttrib, (GLuint vaobj, GLuint index)) \
+    F(void, CreateVertexArrays, (GLsizei n, GLuint *arrays)) \
+    F(void, GetTextureParameteriv, (GLuint texture, GLenum pname, GLint *params)) \
+    F(void, GetTextureParameterIuiv, (GLuint texture, GLenum pname, GLuint *params)) \
+    F(void, GetTextureParameterIiv, (GLuint texture, GLenum pname, GLint *params)) \
+    F(void, GetTextureParameterfv, (GLuint texture, GLenum pname, GLfloat *params)) \
+    F(void, GetTextureLevelParameteriv, (GLuint texture, GLint level, GLenum pname, GLint *params)) \
+    F(void, GetTextureLevelParameterfv, (GLuint texture, GLint level, GLenum pname, GLfloat *params)) \
+    F(void, GetCompressedTextureImage, (GLuint texture, GLint level, GLsizei bufSize, void *pixels)) \
+    F(void, GetTextureImage, (GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)) \
+    F(void, BindTextureUnit, (GLuint unit, GLuint texture)) \
+    F(void, GenerateTextureMipmap, (GLuint texture)) \
+    F(void, TextureParameteriv, (GLuint texture, GLenum pname, const GLint *param)) \
+    F(void, TextureParameterIuiv, (GLuint texture, GLenum pname, const GLuint *params)) \
+    F(void, TextureParameterIiv, (GLuint texture, GLenum pname, const GLint *params)) \
+    F(void, TextureParameteri, (GLuint texture, GLenum pname, GLint param)) \
+    F(void, TextureParameterfv, (GLuint texture, GLenum pname, const GLfloat *param)) \
+    F(void, TextureParameterf, (GLuint texture, GLenum pname, GLfloat param)) \
+    F(void, CopyTextureSubImage3D, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)) \
+    F(void, CopyTextureSubImage2D, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)) \
+    F(void, CopyTextureSubImage1D, (GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)) \
+    F(void, CompressedTextureSubImage3D, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)) \
+    F(void, CompressedTextureSubImage2D, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)) \
+    F(void, CompressedTextureSubImage1D, (GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)) \
+    F(void, TextureSubImage3D, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)) \
+    F(void, TextureSubImage2D, (GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)) \
+    F(void, TextureSubImage1D, (GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)) \
+    F(void, TextureStorage3DMultisample, (GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations)) \
+    F(void, TextureStorage2DMultisample, (GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean fixedsamplelocations)) \
+    F(void, TextureStorage3D, (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)) \
+    F(void, TextureStorage2D, (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)) \
+    F(void, TextureStorage1D, (GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width)) \
+    F(void, TextureBufferRange, (GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizei size)) \
+    F(void, TextureBuffer, (GLuint texture, GLenum internalformat, GLuint buffer)) \
+    F(void, CreateTextures, (GLenum target, GLsizei n, GLuint *textures)) \
+    F(void, GetNamedRenderbufferParameteriv, (GLuint renderbuffer, GLenum pname, GLint *params)) \
+    F(void, NamedRenderbufferStorageMultisample, (GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)) \
+    F(void, NamedRenderbufferStorage, (GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height)) \
+    F(void, CreateRenderbuffers, (GLsizei n, GLuint *renderbuffers)) \
+    F(void, GetNamedFramebufferAttachmentParameteriv, (GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params)) \
+    F(void, GetNamedFramebufferParameteriv, (GLuint framebuffer, GLenum pname, GLint *param)) \
+    F(GLenum, CheckNamedFramebufferStatus, (GLuint framebuffer, GLenum target)) \
+    F(void, BlitNamedFramebuffer, (GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)) \
+    F(void, ClearNamedFramebufferfi, (GLuint framebuffer, GLenum buffer, GLfloat depth, GLint stencil)) \
+    F(void, ClearNamedFramebufferfv, (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value)) \
+    F(void, ClearNamedFramebufferuiv, (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value)) \
+    F(void, ClearNamedFramebufferiv, (GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value)) \
+    F(void, InvalidateNamedFramebufferSubData, (GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)) \
+    F(void, InvalidateNamedFramebufferData, (GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments)) \
+    F(void, NamedFramebufferReadBuffer, (GLuint framebuffer, GLenum src)) \
+    F(void, NamedFramebufferDrawBuffers, (GLuint framebuffer, GLsizei n, const GLenum *bufs)) \
+    F(void, NamedFramebufferDrawBuffer, (GLuint framebuffer, GLenum buf)) \
+    F(void, NamedFramebufferTextureLayer, (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer)) \
+    F(void, NamedFramebufferTexture, (GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)) \
+    F(void, NamedFramebufferParameteri, (GLuint framebuffer, GLenum pname, GLint param)) \
+    F(void, NamedFramebufferRenderbuffer, (GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)) \
+    F(void, CreateFramebuffers, (GLsizei n, GLuint *framebuffers)) \
+    F(void, GetNamedBufferSubData, (GLuint buffer, GLintptr offset, GLsizei size, void *data)) \
+    F(void, GetNamedBufferPointerv, (GLuint buffer, GLenum pname, GLvoid* *params)) \
+    F(void, GetNamedBufferParameteri64v, (GLuint buffer, GLenum pname, GLint64 *params)) \
+    F(void, GetNamedBufferParameteriv, (GLuint buffer, GLenum pname, GLint *params)) \
+    F(void, FlushMappedNamedBufferRange, (GLuint buffer, GLintptr offset, GLsizei length)) \
+    F(GLboolean, UnmapNamedBuffer, (GLuint buffer)) \
+    F(GLvoid *, MapNamedBufferRange, (GLuint buffer, GLintptr offset, GLsizei length, GLbitfield access)) \
+    F(GLvoid *, MapNamedBuffer, (GLuint buffer, GLenum access)) \
+    F(void, ClearNamedBufferSubData, (GLuint buffer, GLenum internalformat, GLintptr offset, GLsizei size, GLenum format, GLenum type, const void *data)) \
+    F(void, ClearNamedBufferData, (GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data)) \
+    F(void, CopyNamedBufferSubData, (GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizei size)) \
+    F(void, NamedBufferSubData, (GLuint buffer, GLintptr offset, GLsizei size, const void *data)) \
+    F(void, NamedBufferData, (GLuint buffer, GLsizei size, const void *data, GLenum usage)) \
+    F(void, NamedBufferStorage, (GLuint buffer, GLsizei size, const void *data, GLbitfield flags)) \
+    F(void, CreateBuffers, (GLsizei n, GLuint *buffers)) \
+    F(void, GetTransformFeedbacki64_v,(GLuint xfb, GLenum pname, GLuint index, GLint64 *param)) \
+    F(void, GetTransformFeedbacki_v,(GLuint xfb, GLenum pname, GLuint index, GLint *param)) \
+    F(void, GetTransformFeedbackiv, (GLuint xfb, GLenum pname, GLint *param)) \
+    F(void, TransformFeedbackBufferRange, (GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizei size)) \
+    F(void, TransformFeedbackBufferBase, (GLuint xfb, GLuint index, GLuint buffer)) \
+    F(void, CreateTransformFeedbacks, (GLsizei n, GLuint *ids)) \
+    F(void, ClipControl, (GLenum origin, GLenum depth)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_4_5_FUNCTIONS);
 };
 
 class QOpenGLFunctions_1_0_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_1_0_DeprecatedBackend(QOpenGLContext *context);
+    QOpenGLFunctions_1_0_DeprecatedBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_1_0_Deprecated; }
 
     // OpenGL 1.0 deprecated functions
-    void (QOPENGLF_APIENTRYP Translatef)(GLfloat x, GLfloat y, GLfloat z);
-    void (QOPENGLF_APIENTRYP Translated)(GLdouble x, GLdouble y, GLdouble z);
-    void (QOPENGLF_APIENTRYP Scalef)(GLfloat x, GLfloat y, GLfloat z);
-    void (QOPENGLF_APIENTRYP Scaled)(GLdouble x, GLdouble y, GLdouble z);
-    void (QOPENGLF_APIENTRYP Rotatef)(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
-    void (QOPENGLF_APIENTRYP Rotated)(GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
-    void (QOPENGLF_APIENTRYP PushMatrix)();
-    void (QOPENGLF_APIENTRYP PopMatrix)();
-    void (QOPENGLF_APIENTRYP Ortho)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    void (QOPENGLF_APIENTRYP MultMatrixd)(const GLdouble *m);
-    void (QOPENGLF_APIENTRYP MultMatrixf)(const GLfloat *m);
-    void (QOPENGLF_APIENTRYP MatrixMode)(GLenum mode);
-    void (QOPENGLF_APIENTRYP LoadMatrixd)(const GLdouble *m);
-    void (QOPENGLF_APIENTRYP LoadMatrixf)(const GLfloat *m);
-    void (QOPENGLF_APIENTRYP LoadIdentity)();
-    void (QOPENGLF_APIENTRYP Frustum)(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
-    GLboolean (QOPENGLF_APIENTRYP IsList)(GLuint list);
-    void (QOPENGLF_APIENTRYP GetTexGeniv)(GLenum coord, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetTexGenfv)(GLenum coord, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetTexGendv)(GLenum coord, GLenum pname, GLdouble *params);
-    void (QOPENGLF_APIENTRYP GetTexEnviv)(GLenum target, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetTexEnvfv)(GLenum target, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetPolygonStipple)(GLubyte *mask);
-    void (QOPENGLF_APIENTRYP GetPixelMapusv)(GLenum map, GLushort *values);
-    void (QOPENGLF_APIENTRYP GetPixelMapuiv)(GLenum map, GLuint *values);
-    void (QOPENGLF_APIENTRYP GetPixelMapfv)(GLenum map, GLfloat *values);
-    void (QOPENGLF_APIENTRYP GetMaterialiv)(GLenum face, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetMaterialfv)(GLenum face, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetMapiv)(GLenum target, GLenum query, GLint *v);
-    void (QOPENGLF_APIENTRYP GetMapfv)(GLenum target, GLenum query, GLfloat *v);
-    void (QOPENGLF_APIENTRYP GetMapdv)(GLenum target, GLenum query, GLdouble *v);
-    void (QOPENGLF_APIENTRYP GetLightiv)(GLenum light, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetLightfv)(GLenum light, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetClipPlane)(GLenum plane, GLdouble *equation);
-    void (QOPENGLF_APIENTRYP DrawPixels)(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels);
-    void (QOPENGLF_APIENTRYP CopyPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type);
-    void (QOPENGLF_APIENTRYP PixelMapusv)(GLenum map, GLsizei mapsize, const GLushort *values);
-    void (QOPENGLF_APIENTRYP PixelMapuiv)(GLenum map, GLsizei mapsize, const GLuint *values);
-    void (QOPENGLF_APIENTRYP PixelMapfv)(GLenum map, GLsizei mapsize, const GLfloat *values);
-    void (QOPENGLF_APIENTRYP PixelTransferi)(GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP PixelTransferf)(GLenum pname, GLfloat param);
-    void (QOPENGLF_APIENTRYP PixelZoom)(GLfloat xfactor, GLfloat yfactor);
-    void (QOPENGLF_APIENTRYP AlphaFunc)(GLenum func, GLfloat ref);
-    void (QOPENGLF_APIENTRYP EvalPoint2)(GLint i, GLint j);
-    void (QOPENGLF_APIENTRYP EvalMesh2)(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2);
-    void (QOPENGLF_APIENTRYP EvalPoint1)(GLint i);
-    void (QOPENGLF_APIENTRYP EvalMesh1)(GLenum mode, GLint i1, GLint i2);
-    void (QOPENGLF_APIENTRYP EvalCoord2fv)(const GLfloat *u);
-    void (QOPENGLF_APIENTRYP EvalCoord2f)(GLfloat u, GLfloat v);
-    void (QOPENGLF_APIENTRYP EvalCoord2dv)(const GLdouble *u);
-    void (QOPENGLF_APIENTRYP EvalCoord2d)(GLdouble u, GLdouble v);
-    void (QOPENGLF_APIENTRYP EvalCoord1fv)(const GLfloat *u);
-    void (QOPENGLF_APIENTRYP EvalCoord1f)(GLfloat u);
-    void (QOPENGLF_APIENTRYP EvalCoord1dv)(const GLdouble *u);
-    void (QOPENGLF_APIENTRYP EvalCoord1d)(GLdouble u);
-    void (QOPENGLF_APIENTRYP MapGrid2f)(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2);
-    void (QOPENGLF_APIENTRYP MapGrid2d)(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2);
-    void (QOPENGLF_APIENTRYP MapGrid1f)(GLint un, GLfloat u1, GLfloat u2);
-    void (QOPENGLF_APIENTRYP MapGrid1d)(GLint un, GLdouble u1, GLdouble u2);
-    void (QOPENGLF_APIENTRYP Map2f)(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points);
-    void (QOPENGLF_APIENTRYP Map2d)(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points);
-    void (QOPENGLF_APIENTRYP Map1f)(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points);
-    void (QOPENGLF_APIENTRYP Map1d)(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points);
-    void (QOPENGLF_APIENTRYP PushAttrib)(GLbitfield mask);
-    void (QOPENGLF_APIENTRYP PopAttrib)();
-    void (QOPENGLF_APIENTRYP Accum)(GLenum op, GLfloat value);
-    void (QOPENGLF_APIENTRYP IndexMask)(GLuint mask);
-    void (QOPENGLF_APIENTRYP ClearIndex)(GLfloat c);
-    void (QOPENGLF_APIENTRYP ClearAccum)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void (QOPENGLF_APIENTRYP PushName)(GLuint name);
-    void (QOPENGLF_APIENTRYP PopName)();
-    void (QOPENGLF_APIENTRYP PassThrough)(GLfloat token);
-    void (QOPENGLF_APIENTRYP LoadName)(GLuint name);
-    void (QOPENGLF_APIENTRYP InitNames)();
-    GLint (QOPENGLF_APIENTRYP RenderMode)(GLenum mode);
-    void (QOPENGLF_APIENTRYP SelectBuffer)(GLsizei size, GLuint *buffer);
-    void (QOPENGLF_APIENTRYP FeedbackBuffer)(GLsizei size, GLenum type, GLfloat *buffer);
-    void (QOPENGLF_APIENTRYP TexGeniv)(GLenum coord, GLenum pname, const GLint *params);
-    void (QOPENGLF_APIENTRYP TexGeni)(GLenum coord, GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP TexGenfv)(GLenum coord, GLenum pname, const GLfloat *params);
-    void (QOPENGLF_APIENTRYP TexGenf)(GLenum coord, GLenum pname, GLfloat param);
-    void (QOPENGLF_APIENTRYP TexGendv)(GLenum coord, GLenum pname, const GLdouble *params);
-    void (QOPENGLF_APIENTRYP TexGend)(GLenum coord, GLenum pname, GLdouble param);
-    void (QOPENGLF_APIENTRYP TexEnviv)(GLenum target, GLenum pname, const GLint *params);
-    void (QOPENGLF_APIENTRYP TexEnvi)(GLenum target, GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP TexEnvfv)(GLenum target, GLenum pname, const GLfloat *params);
-    void (QOPENGLF_APIENTRYP TexEnvf)(GLenum target, GLenum pname, GLfloat param);
-    void (QOPENGLF_APIENTRYP ShadeModel)(GLenum mode);
-    void (QOPENGLF_APIENTRYP PolygonStipple)(const GLubyte *mask);
-    void (QOPENGLF_APIENTRYP Materialiv)(GLenum face, GLenum pname, const GLint *params);
-    void (QOPENGLF_APIENTRYP Materiali)(GLenum face, GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP Materialfv)(GLenum face, GLenum pname, const GLfloat *params);
-    void (QOPENGLF_APIENTRYP Materialf)(GLenum face, GLenum pname, GLfloat param);
-    void (QOPENGLF_APIENTRYP LineStipple)(GLint factor, GLushort pattern);
-    void (QOPENGLF_APIENTRYP LightModeliv)(GLenum pname, const GLint *params);
-    void (QOPENGLF_APIENTRYP LightModeli)(GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP LightModelfv)(GLenum pname, const GLfloat *params);
-    void (QOPENGLF_APIENTRYP LightModelf)(GLenum pname, GLfloat param);
-    void (QOPENGLF_APIENTRYP Lightiv)(GLenum light, GLenum pname, const GLint *params);
-    void (QOPENGLF_APIENTRYP Lighti)(GLenum light, GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP Lightfv)(GLenum light, GLenum pname, const GLfloat *params);
-    void (QOPENGLF_APIENTRYP Lightf)(GLenum light, GLenum pname, GLfloat param);
-    void (QOPENGLF_APIENTRYP Fogiv)(GLenum pname, const GLint *params);
-    void (QOPENGLF_APIENTRYP Fogi)(GLenum pname, GLint param);
-    void (QOPENGLF_APIENTRYP Fogfv)(GLenum pname, const GLfloat *params);
-    void (QOPENGLF_APIENTRYP Fogf)(GLenum pname, GLfloat param);
-    void (QOPENGLF_APIENTRYP ColorMaterial)(GLenum face, GLenum mode);
-    void (QOPENGLF_APIENTRYP ClipPlane)(GLenum plane, const GLdouble *equation);
-    void (QOPENGLF_APIENTRYP Vertex4sv)(const GLshort *v);
-    void (QOPENGLF_APIENTRYP Vertex4s)(GLshort x, GLshort y, GLshort z, GLshort w);
-    void (QOPENGLF_APIENTRYP Vertex4iv)(const GLint *v);
-    void (QOPENGLF_APIENTRYP Vertex4i)(GLint x, GLint y, GLint z, GLint w);
-    void (QOPENGLF_APIENTRYP Vertex4fv)(const GLfloat *v);
-    void (QOPENGLF_APIENTRYP Vertex4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void (QOPENGLF_APIENTRYP Vertex4dv)(const GLdouble *v);
-    void (QOPENGLF_APIENTRYP Vertex4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void (QOPENGLF_APIENTRYP Vertex3sv)(const GLshort *v);
-    void (QOPENGLF_APIENTRYP Vertex3s)(GLshort x, GLshort y, GLshort z);
-    void (QOPENGLF_APIENTRYP Vertex3iv)(const GLint *v);
-    void (QOPENGLF_APIENTRYP Vertex3i)(GLint x, GLint y, GLint z);
-    void (QOPENGLF_APIENTRYP Vertex3fv)(const GLfloat *v);
-    void (QOPENGLF_APIENTRYP Vertex3f)(GLfloat x, GLfloat y, GLfloat z);
-    void (QOPENGLF_APIENTRYP Vertex3dv)(const GLdouble *v);
-    void (QOPENGLF_APIENTRYP Vertex3d)(GLdouble x, GLdouble y, GLdouble z);
-    void (QOPENGLF_APIENTRYP Vertex2sv)(const GLshort *v);
-    void (QOPENGLF_APIENTRYP Vertex2s)(GLshort x, GLshort y);
-    void (QOPENGLF_APIENTRYP Vertex2iv)(const GLint *v);
-    void (QOPENGLF_APIENTRYP Vertex2i)(GLint x, GLint y);
-    void (QOPENGLF_APIENTRYP Vertex2fv)(const GLfloat *v);
-    void (QOPENGLF_APIENTRYP Vertex2f)(GLfloat x, GLfloat y);
-    void (QOPENGLF_APIENTRYP Vertex2dv)(const GLdouble *v);
-    void (QOPENGLF_APIENTRYP Vertex2d)(GLdouble x, GLdouble y);
-    void (QOPENGLF_APIENTRYP TexCoord4sv)(const GLshort *v);
-    void (QOPENGLF_APIENTRYP TexCoord4s)(GLshort s, GLshort t, GLshort r, GLshort q);
-    void (QOPENGLF_APIENTRYP TexCoord4iv)(const GLint *v);
-    void (QOPENGLF_APIENTRYP TexCoord4i)(GLint s, GLint t, GLint r, GLint q);
-    void (QOPENGLF_APIENTRYP TexCoord4fv)(const GLfloat *v);
-    void (QOPENGLF_APIENTRYP TexCoord4f)(GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void (QOPENGLF_APIENTRYP TexCoord4dv)(const GLdouble *v);
-    void (QOPENGLF_APIENTRYP TexCoord4d)(GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void (QOPENGLF_APIENTRYP TexCoord3sv)(const GLshort *v);
-    void (QOPENGLF_APIENTRYP TexCoord3s)(GLshort s, GLshort t, GLshort r);
-    void (QOPENGLF_APIENTRYP TexCoord3iv)(const GLint *v);
-    void (QOPENGLF_APIENTRYP TexCoord3i)(GLint s, GLint t, GLint r);
-    void (QOPENGLF_APIENTRYP TexCoord3fv)(const GLfloat *v);
-    void (QOPENGLF_APIENTRYP TexCoord3f)(GLfloat s, GLfloat t, GLfloat r);
-    void (QOPENGLF_APIENTRYP TexCoord3dv)(const GLdouble *v);
-    void (QOPENGLF_APIENTRYP TexCoord3d)(GLdouble s, GLdouble t, GLdouble r);
-    void (QOPENGLF_APIENTRYP TexCoord2sv)(const GLshort *v);
-    void (QOPENGLF_APIENTRYP TexCoord2s)(GLshort s, GLshort t);
-    void (QOPENGLF_APIENTRYP TexCoord2iv)(const GLint *v);
-    void (QOPENGLF_APIENTRYP TexCoord2i)(GLint s, GLint t);
-    void (QOPENGLF_APIENTRYP TexCoord2fv)(const GLfloat *v);
-    void (QOPENGLF_APIENTRYP TexCoord2f)(GLfloat s, GLfloat t);
-    void (QOPENGLF_APIENTRYP TexCoord2dv)(const GLdouble *v);
-    void (QOPENGLF_APIENTRYP TexCoord2d)(GLdouble s, GLdouble t);
-    void (QOPENGLF_APIENTRYP TexCoord1sv)(const GLshort *v);
-    void (QOPENGLF_APIENTRYP TexCoord1s)(GLshort s);
-    void (QOPENGLF_APIENTRYP TexCoord1iv)(const GLint *v);
-    void (QOPENGLF_APIENTRYP TexCoord1i)(GLint s);
-    void (QOPENGLF_APIENTRYP TexCoord1fv)(const GLfloat *v);
-    void (QOPENGLF_APIENTRYP TexCoord1f)(GLfloat s);
-    void (QOPENGLF_APIENTRYP TexCoord1dv)(const GLdouble *v);
-    void (QOPENGLF_APIENTRYP TexCoord1d)(GLdouble s);
-    void (QOPENGLF_APIENTRYP Rectsv)(const GLshort *v1, const GLshort *v2);
-    void (QOPENGLF_APIENTRYP Rects)(GLshort x1, GLshort y1, GLshort x2, GLshort y2);
-    void (QOPENGLF_APIENTRYP Rectiv)(const GLint *v1, const GLint *v2);
-    void (QOPENGLF_APIENTRYP Recti)(GLint x1, GLint y1, GLint x2, GLint y2);
-    void (QOPENGLF_APIENTRYP Rectfv)(const GLfloat *v1, const GLfloat *v2);
-    void (QOPENGLF_APIENTRYP Rectf)(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2);
-    void (QOPENGLF_APIENTRYP Rectdv)(const GLdouble *v1, const GLdouble *v2);
-    void (QOPENGLF_APIENTRYP Rectd)(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2);
-    void (QOPENGLF_APIENTRYP RasterPos4sv)(const GLshort *v);
-    void (QOPENGLF_APIENTRYP RasterPos4s)(GLshort x, GLshort y, GLshort z, GLshort w);
-    void (QOPENGLF_APIENTRYP RasterPos4iv)(const GLint *v);
-    void (QOPENGLF_APIENTRYP RasterPos4i)(GLint x, GLint y, GLint z, GLint w);
-    void (QOPENGLF_APIENTRYP RasterPos4fv)(const GLfloat *v);
-    void (QOPENGLF_APIENTRYP RasterPos4f)(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void (QOPENGLF_APIENTRYP RasterPos4dv)(const GLdouble *v);
-    void (QOPENGLF_APIENTRYP RasterPos4d)(GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void (QOPENGLF_APIENTRYP RasterPos3sv)(const GLshort *v);
-    void (QOPENGLF_APIENTRYP RasterPos3s)(GLshort x, GLshort y, GLshort z);
-    void (QOPENGLF_APIENTRYP RasterPos3iv)(const GLint *v);
-    void (QOPENGLF_APIENTRYP RasterPos3i)(GLint x, GLint y, GLint z);
-    void (QOPENGLF_APIENTRYP RasterPos3fv)(const GLfloat *v);
-    void (QOPENGLF_APIENTRYP RasterPos3f)(GLfloat x, GLfloat y, GLfloat z);
-    void (QOPENGLF_APIENTRYP RasterPos3dv)(const GLdouble *v);
-    void (QOPENGLF_APIENTRYP RasterPos3d)(GLdouble x, GLdouble y, GLdouble z);
-    void (QOPENGLF_APIENTRYP RasterPos2sv)(const GLshort *v);
-    void (QOPENGLF_APIENTRYP RasterPos2s)(GLshort x, GLshort y);
-    void (QOPENGLF_APIENTRYP RasterPos2iv)(const GLint *v);
-    void (QOPENGLF_APIENTRYP RasterPos2i)(GLint x, GLint y);
-    void (QOPENGLF_APIENTRYP RasterPos2fv)(const GLfloat *v);
-    void (QOPENGLF_APIENTRYP RasterPos2f)(GLfloat x, GLfloat y);
-    void (QOPENGLF_APIENTRYP RasterPos2dv)(const GLdouble *v);
-    void (QOPENGLF_APIENTRYP RasterPos2d)(GLdouble x, GLdouble y);
-    void (QOPENGLF_APIENTRYP Normal3sv)(const GLshort *v);
-    void (QOPENGLF_APIENTRYP Normal3s)(GLshort nx, GLshort ny, GLshort nz);
-    void (QOPENGLF_APIENTRYP Normal3iv)(const GLint *v);
-    void (QOPENGLF_APIENTRYP Normal3i)(GLint nx, GLint ny, GLint nz);
-    void (QOPENGLF_APIENTRYP Normal3fv)(const GLfloat *v);
-    void (QOPENGLF_APIENTRYP Normal3f)(GLfloat nx, GLfloat ny, GLfloat nz);
-    void (QOPENGLF_APIENTRYP Normal3dv)(const GLdouble *v);
-    void (QOPENGLF_APIENTRYP Normal3d)(GLdouble nx, GLdouble ny, GLdouble nz);
-    void (QOPENGLF_APIENTRYP Normal3bv)(const GLbyte *v);
-    void (QOPENGLF_APIENTRYP Normal3b)(GLbyte nx, GLbyte ny, GLbyte nz);
-    void (QOPENGLF_APIENTRYP Indexsv)(const GLshort *c);
-    void (QOPENGLF_APIENTRYP Indexs)(GLshort c);
-    void (QOPENGLF_APIENTRYP Indexiv)(const GLint *c);
-    void (QOPENGLF_APIENTRYP Indexi)(GLint c);
-    void (QOPENGLF_APIENTRYP Indexfv)(const GLfloat *c);
-    void (QOPENGLF_APIENTRYP Indexf)(GLfloat c);
-    void (QOPENGLF_APIENTRYP Indexdv)(const GLdouble *c);
-    void (QOPENGLF_APIENTRYP Indexd)(GLdouble c);
-    void (QOPENGLF_APIENTRYP End)();
-    void (QOPENGLF_APIENTRYP EdgeFlagv)(const GLboolean *flag);
-    void (QOPENGLF_APIENTRYP EdgeFlag)(GLboolean flag);
-    void (QOPENGLF_APIENTRYP Color4usv)(const GLushort *v);
-    void (QOPENGLF_APIENTRYP Color4us)(GLushort red, GLushort green, GLushort blue, GLushort alpha);
-    void (QOPENGLF_APIENTRYP Color4uiv)(const GLuint *v);
-    void (QOPENGLF_APIENTRYP Color4ui)(GLuint red, GLuint green, GLuint blue, GLuint alpha);
-    void (QOPENGLF_APIENTRYP Color4ubv)(const GLubyte *v);
-    void (QOPENGLF_APIENTRYP Color4ub)(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha);
-    void (QOPENGLF_APIENTRYP Color4sv)(const GLshort *v);
-    void (QOPENGLF_APIENTRYP Color4s)(GLshort red, GLshort green, GLshort blue, GLshort alpha);
-    void (QOPENGLF_APIENTRYP Color4iv)(const GLint *v);
-    void (QOPENGLF_APIENTRYP Color4i)(GLint red, GLint green, GLint blue, GLint alpha);
-    void (QOPENGLF_APIENTRYP Color4fv)(const GLfloat *v);
-    void (QOPENGLF_APIENTRYP Color4f)(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha);
-    void (QOPENGLF_APIENTRYP Color4dv)(const GLdouble *v);
-    void (QOPENGLF_APIENTRYP Color4d)(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha);
-    void (QOPENGLF_APIENTRYP Color4bv)(const GLbyte *v);
-    void (QOPENGLF_APIENTRYP Color4b)(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha);
-    void (QOPENGLF_APIENTRYP Color3usv)(const GLushort *v);
-    void (QOPENGLF_APIENTRYP Color3us)(GLushort red, GLushort green, GLushort blue);
-    void (QOPENGLF_APIENTRYP Color3uiv)(const GLuint *v);
-    void (QOPENGLF_APIENTRYP Color3ui)(GLuint red, GLuint green, GLuint blue);
-    void (QOPENGLF_APIENTRYP Color3ubv)(const GLubyte *v);
-    void (QOPENGLF_APIENTRYP Color3ub)(GLubyte red, GLubyte green, GLubyte blue);
-    void (QOPENGLF_APIENTRYP Color3sv)(const GLshort *v);
-    void (QOPENGLF_APIENTRYP Color3s)(GLshort red, GLshort green, GLshort blue);
-    void (QOPENGLF_APIENTRYP Color3iv)(const GLint *v);
-    void (QOPENGLF_APIENTRYP Color3i)(GLint red, GLint green, GLint blue);
-    void (QOPENGLF_APIENTRYP Color3fv)(const GLfloat *v);
-    void (QOPENGLF_APIENTRYP Color3f)(GLfloat red, GLfloat green, GLfloat blue);
-    void (QOPENGLF_APIENTRYP Color3dv)(const GLdouble *v);
-    void (QOPENGLF_APIENTRYP Color3d)(GLdouble red, GLdouble green, GLdouble blue);
-    void (QOPENGLF_APIENTRYP Color3bv)(const GLbyte *v);
-    void (QOPENGLF_APIENTRYP Color3b)(GLbyte red, GLbyte green, GLbyte blue);
-    void (QOPENGLF_APIENTRYP Bitmap)(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap);
-    void (QOPENGLF_APIENTRYP Begin)(GLenum mode);
-    void (QOPENGLF_APIENTRYP ListBase)(GLuint base);
-    GLuint (QOPENGLF_APIENTRYP GenLists)(GLsizei range);
-    void (QOPENGLF_APIENTRYP DeleteLists)(GLuint list, GLsizei range);
-    void (QOPENGLF_APIENTRYP CallLists)(GLsizei n, GLenum type, const GLvoid *lists);
-    void (QOPENGLF_APIENTRYP CallList)(GLuint list);
-    void (QOPENGLF_APIENTRYP EndList)();
-    void (QOPENGLF_APIENTRYP NewList)(GLuint list, GLenum mode);
+#define QT_OPENGL_1_0_DEPRECATED_FUNCTIONS(F) \
+    F(void, Translatef, (GLfloat x, GLfloat y, GLfloat z)) \
+    F(void, Translated, (GLdouble x, GLdouble y, GLdouble z)) \
+    F(void, Scalef, (GLfloat x, GLfloat y, GLfloat z)) \
+    F(void, Scaled, (GLdouble x, GLdouble y, GLdouble z)) \
+    F(void, Rotatef, (GLfloat angle, GLfloat x, GLfloat y, GLfloat z)) \
+    F(void, Rotated, (GLdouble angle, GLdouble x, GLdouble y, GLdouble z)) \
+    F(void, PushMatrix, ()) \
+    F(void, PopMatrix, ()) \
+    F(void, Ortho, (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)) \
+    F(void, MultMatrixd, (const GLdouble *m)) \
+    F(void, MultMatrixf, (const GLfloat *m)) \
+    F(void, MatrixMode, (GLenum mode)) \
+    F(void, LoadMatrixd, (const GLdouble *m)) \
+    F(void, LoadMatrixf, (const GLfloat *m)) \
+    F(void, LoadIdentity, ()) \
+    F(void, Frustum, (GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)) \
+    F(GLboolean, IsList, (GLuint list)) \
+    F(void, GetTexGeniv, (GLenum coord, GLenum pname, GLint *params)) \
+    F(void, GetTexGenfv, (GLenum coord, GLenum pname, GLfloat *params)) \
+    F(void, GetTexGendv, (GLenum coord, GLenum pname, GLdouble *params)) \
+    F(void, GetTexEnviv, (GLenum target, GLenum pname, GLint *params)) \
+    F(void, GetTexEnvfv, (GLenum target, GLenum pname, GLfloat *params)) \
+    F(void, GetPolygonStipple, (GLubyte *mask)) \
+    F(void, GetPixelMapusv, (GLenum map, GLushort *values)) \
+    F(void, GetPixelMapuiv, (GLenum map, GLuint *values)) \
+    F(void, GetPixelMapfv, (GLenum map, GLfloat *values)) \
+    F(void, GetMaterialiv, (GLenum face, GLenum pname, GLint *params)) \
+    F(void, GetMaterialfv, (GLenum face, GLenum pname, GLfloat *params)) \
+    F(void, GetMapiv, (GLenum target, GLenum query, GLint *v)) \
+    F(void, GetMapfv, (GLenum target, GLenum query, GLfloat *v)) \
+    F(void, GetMapdv, (GLenum target, GLenum query, GLdouble *v)) \
+    F(void, GetLightiv, (GLenum light, GLenum pname, GLint *params)) \
+    F(void, GetLightfv, (GLenum light, GLenum pname, GLfloat *params)) \
+    F(void, GetClipPlane, (GLenum plane, GLdouble *equation)) \
+    F(void, DrawPixels, (GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)) \
+    F(void, CopyPixels, (GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)) \
+    F(void, PixelMapusv, (GLenum map, GLsizei mapsize, const GLushort *values)) \
+    F(void, PixelMapuiv, (GLenum map, GLsizei mapsize, const GLuint *values)) \
+    F(void, PixelMapfv, (GLenum map, GLsizei mapsize, const GLfloat *values)) \
+    F(void, PixelTransferi, (GLenum pname, GLint param)) \
+    F(void, PixelTransferf, (GLenum pname, GLfloat param)) \
+    F(void, PixelZoom, (GLfloat xfactor, GLfloat yfactor)) \
+    F(void, AlphaFunc, (GLenum func, GLfloat ref)) \
+    F(void, EvalPoint2, (GLint i, GLint j)) \
+    F(void, EvalMesh2, (GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)) \
+    F(void, EvalPoint1, (GLint i)) \
+    F(void, EvalMesh1, (GLenum mode, GLint i1, GLint i2)) \
+    F(void, EvalCoord2fv, (const GLfloat *u)) \
+    F(void, EvalCoord2f, (GLfloat u, GLfloat v)) \
+    F(void, EvalCoord2dv, (const GLdouble *u)) \
+    F(void, EvalCoord2d, (GLdouble u, GLdouble v)) \
+    F(void, EvalCoord1fv, (const GLfloat *u)) \
+    F(void, EvalCoord1f, (GLfloat u)) \
+    F(void, EvalCoord1dv, (const GLdouble *u)) \
+    F(void, EvalCoord1d, (GLdouble u)) \
+    F(void, MapGrid2f, (GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)) \
+    F(void, MapGrid2d, (GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)) \
+    F(void, MapGrid1f, (GLint un, GLfloat u1, GLfloat u2)) \
+    F(void, MapGrid1d, (GLint un, GLdouble u1, GLdouble u2)) \
+    F(void, Map2f, (GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)) \
+    F(void, Map2d, (GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)) \
+    F(void, Map1f, (GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)) \
+    F(void, Map1d, (GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)) \
+    F(void, PushAttrib, (GLbitfield mask)) \
+    F(void, PopAttrib, ()) \
+    F(void, Accum, (GLenum op, GLfloat value)) \
+    F(void, IndexMask, (GLuint mask)) \
+    F(void, ClearIndex, (GLfloat c)) \
+    F(void, ClearAccum, (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)) \
+    F(void, PushName, (GLuint name)) \
+    F(void, PopName, ()) \
+    F(void, PassThrough, (GLfloat token)) \
+    F(void, LoadName, (GLuint name)) \
+    F(void, InitNames, ()) \
+    F(GLint, RenderMode, (GLenum mode)) \
+    F(void, SelectBuffer, (GLsizei size, GLuint *buffer)) \
+    F(void, FeedbackBuffer, (GLsizei size, GLenum type, GLfloat *buffer)) \
+    F(void, TexGeniv, (GLenum coord, GLenum pname, const GLint *params)) \
+    F(void, TexGeni, (GLenum coord, GLenum pname, GLint param)) \
+    F(void, TexGenfv, (GLenum coord, GLenum pname, const GLfloat *params)) \
+    F(void, TexGenf, (GLenum coord, GLenum pname, GLfloat param)) \
+    F(void, TexGendv, (GLenum coord, GLenum pname, const GLdouble *params)) \
+    F(void, TexGend, (GLenum coord, GLenum pname, GLdouble param)) \
+    F(void, TexEnviv, (GLenum target, GLenum pname, const GLint *params)) \
+    F(void, TexEnvi, (GLenum target, GLenum pname, GLint param)) \
+    F(void, TexEnvfv, (GLenum target, GLenum pname, const GLfloat *params)) \
+    F(void, TexEnvf, (GLenum target, GLenum pname, GLfloat param)) \
+    F(void, ShadeModel, (GLenum mode)) \
+    F(void, PolygonStipple, (const GLubyte *mask)) \
+    F(void, Materialiv, (GLenum face, GLenum pname, const GLint *params)) \
+    F(void, Materiali, (GLenum face, GLenum pname, GLint param)) \
+    F(void, Materialfv, (GLenum face, GLenum pname, const GLfloat *params)) \
+    F(void, Materialf, (GLenum face, GLenum pname, GLfloat param)) \
+    F(void, LineStipple, (GLint factor, GLushort pattern)) \
+    F(void, LightModeliv, (GLenum pname, const GLint *params)) \
+    F(void, LightModeli, (GLenum pname, GLint param)) \
+    F(void, LightModelfv, (GLenum pname, const GLfloat *params)) \
+    F(void, LightModelf, (GLenum pname, GLfloat param)) \
+    F(void, Lightiv, (GLenum light, GLenum pname, const GLint *params)) \
+    F(void, Lighti, (GLenum light, GLenum pname, GLint param)) \
+    F(void, Lightfv, (GLenum light, GLenum pname, const GLfloat *params)) \
+    F(void, Lightf, (GLenum light, GLenum pname, GLfloat param)) \
+    F(void, Fogiv, (GLenum pname, const GLint *params)) \
+    F(void, Fogi, (GLenum pname, GLint param)) \
+    F(void, Fogfv, (GLenum pname, const GLfloat *params)) \
+    F(void, Fogf, (GLenum pname, GLfloat param)) \
+    F(void, ColorMaterial, (GLenum face, GLenum mode)) \
+    F(void, ClipPlane, (GLenum plane, const GLdouble *equation)) \
+    F(void, Vertex4sv, (const GLshort *v)) \
+    F(void, Vertex4s, (GLshort x, GLshort y, GLshort z, GLshort w)) \
+    F(void, Vertex4iv, (const GLint *v)) \
+    F(void, Vertex4i, (GLint x, GLint y, GLint z, GLint w)) \
+    F(void, Vertex4fv, (const GLfloat *v)) \
+    F(void, Vertex4f, (GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
+    F(void, Vertex4dv, (const GLdouble *v)) \
+    F(void, Vertex4d, (GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
+    F(void, Vertex3sv, (const GLshort *v)) \
+    F(void, Vertex3s, (GLshort x, GLshort y, GLshort z)) \
+    F(void, Vertex3iv, (const GLint *v)) \
+    F(void, Vertex3i, (GLint x, GLint y, GLint z)) \
+    F(void, Vertex3fv, (const GLfloat *v)) \
+    F(void, Vertex3f, (GLfloat x, GLfloat y, GLfloat z)) \
+    F(void, Vertex3dv, (const GLdouble *v)) \
+    F(void, Vertex3d, (GLdouble x, GLdouble y, GLdouble z)) \
+    F(void, Vertex2sv, (const GLshort *v)) \
+    F(void, Vertex2s, (GLshort x, GLshort y)) \
+    F(void, Vertex2iv, (const GLint *v)) \
+    F(void, Vertex2i, (GLint x, GLint y)) \
+    F(void, Vertex2fv, (const GLfloat *v)) \
+    F(void, Vertex2f, (GLfloat x, GLfloat y)) \
+    F(void, Vertex2dv, (const GLdouble *v)) \
+    F(void, Vertex2d, (GLdouble x, GLdouble y)) \
+    F(void, TexCoord4sv, (const GLshort *v)) \
+    F(void, TexCoord4s, (GLshort s, GLshort t, GLshort r, GLshort q)) \
+    F(void, TexCoord4iv, (const GLint *v)) \
+    F(void, TexCoord4i, (GLint s, GLint t, GLint r, GLint q)) \
+    F(void, TexCoord4fv, (const GLfloat *v)) \
+    F(void, TexCoord4f, (GLfloat s, GLfloat t, GLfloat r, GLfloat q)) \
+    F(void, TexCoord4dv, (const GLdouble *v)) \
+    F(void, TexCoord4d, (GLdouble s, GLdouble t, GLdouble r, GLdouble q)) \
+    F(void, TexCoord3sv, (const GLshort *v)) \
+    F(void, TexCoord3s, (GLshort s, GLshort t, GLshort r)) \
+    F(void, TexCoord3iv, (const GLint *v)) \
+    F(void, TexCoord3i, (GLint s, GLint t, GLint r)) \
+    F(void, TexCoord3fv, (const GLfloat *v)) \
+    F(void, TexCoord3f, (GLfloat s, GLfloat t, GLfloat r)) \
+    F(void, TexCoord3dv, (const GLdouble *v)) \
+    F(void, TexCoord3d, (GLdouble s, GLdouble t, GLdouble r)) \
+    F(void, TexCoord2sv, (const GLshort *v)) \
+    F(void, TexCoord2s, (GLshort s, GLshort t)) \
+    F(void, TexCoord2iv, (const GLint *v)) \
+    F(void, TexCoord2i, (GLint s, GLint t)) \
+    F(void, TexCoord2fv, (const GLfloat *v)) \
+    F(void, TexCoord2f, (GLfloat s, GLfloat t)) \
+    F(void, TexCoord2dv, (const GLdouble *v)) \
+    F(void, TexCoord2d, (GLdouble s, GLdouble t)) \
+    F(void, TexCoord1sv, (const GLshort *v)) \
+    F(void, TexCoord1s, (GLshort s)) \
+    F(void, TexCoord1iv, (const GLint *v)) \
+    F(void, TexCoord1i, (GLint s)) \
+    F(void, TexCoord1fv, (const GLfloat *v)) \
+    F(void, TexCoord1f, (GLfloat s)) \
+    F(void, TexCoord1dv, (const GLdouble *v)) \
+    F(void, TexCoord1d, (GLdouble s)) \
+    F(void, Rectsv, (const GLshort *v1, const GLshort *v2)) \
+    F(void, Rects, (GLshort x1, GLshort y1, GLshort x2, GLshort y2)) \
+    F(void, Rectiv, (const GLint *v1, const GLint *v2)) \
+    F(void, Recti, (GLint x1, GLint y1, GLint x2, GLint y2)) \
+    F(void, Rectfv, (const GLfloat *v1, const GLfloat *v2)) \
+    F(void, Rectf, (GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)) \
+    F(void, Rectdv, (const GLdouble *v1, const GLdouble *v2)) \
+    F(void, Rectd, (GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)) \
+    F(void, RasterPos4sv, (const GLshort *v)) \
+    F(void, RasterPos4s, (GLshort x, GLshort y, GLshort z, GLshort w)) \
+    F(void, RasterPos4iv, (const GLint *v)) \
+    F(void, RasterPos4i, (GLint x, GLint y, GLint z, GLint w)) \
+    F(void, RasterPos4fv, (const GLfloat *v)) \
+    F(void, RasterPos4f, (GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
+    F(void, RasterPos4dv, (const GLdouble *v)) \
+    F(void, RasterPos4d, (GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
+    F(void, RasterPos3sv, (const GLshort *v)) \
+    F(void, RasterPos3s, (GLshort x, GLshort y, GLshort z)) \
+    F(void, RasterPos3iv, (const GLint *v)) \
+    F(void, RasterPos3i, (GLint x, GLint y, GLint z)) \
+    F(void, RasterPos3fv, (const GLfloat *v)) \
+    F(void, RasterPos3f, (GLfloat x, GLfloat y, GLfloat z)) \
+    F(void, RasterPos3dv, (const GLdouble *v)) \
+    F(void, RasterPos3d, (GLdouble x, GLdouble y, GLdouble z)) \
+    F(void, RasterPos2sv, (const GLshort *v)) \
+    F(void, RasterPos2s, (GLshort x, GLshort y)) \
+    F(void, RasterPos2iv, (const GLint *v)) \
+    F(void, RasterPos2i, (GLint x, GLint y)) \
+    F(void, RasterPos2fv, (const GLfloat *v)) \
+    F(void, RasterPos2f, (GLfloat x, GLfloat y)) \
+    F(void, RasterPos2dv, (const GLdouble *v)) \
+    F(void, RasterPos2d, (GLdouble x, GLdouble y)) \
+    F(void, Normal3sv, (const GLshort *v)) \
+    F(void, Normal3s, (GLshort nx, GLshort ny, GLshort nz)) \
+    F(void, Normal3iv, (const GLint *v)) \
+    F(void, Normal3i, (GLint nx, GLint ny, GLint nz)) \
+    F(void, Normal3fv, (const GLfloat *v)) \
+    F(void, Normal3f, (GLfloat nx, GLfloat ny, GLfloat nz)) \
+    F(void, Normal3dv, (const GLdouble *v)) \
+    F(void, Normal3d, (GLdouble nx, GLdouble ny, GLdouble nz)) \
+    F(void, Normal3bv, (const GLbyte *v)) \
+    F(void, Normal3b, (GLbyte nx, GLbyte ny, GLbyte nz)) \
+    F(void, Indexsv, (const GLshort *c)) \
+    F(void, Indexs, (GLshort c)) \
+    F(void, Indexiv, (const GLint *c)) \
+    F(void, Indexi, (GLint c)) \
+    F(void, Indexfv, (const GLfloat *c)) \
+    F(void, Indexf, (GLfloat c)) \
+    F(void, Indexdv, (const GLdouble *c)) \
+    F(void, Indexd, (GLdouble c)) \
+    F(void, End, ()) \
+    F(void, EdgeFlagv, (const GLboolean *flag)) \
+    F(void, EdgeFlag, (GLboolean flag)) \
+    F(void, Color4usv, (const GLushort *v)) \
+    F(void, Color4us, (GLushort red, GLushort green, GLushort blue, GLushort alpha)) \
+    F(void, Color4uiv, (const GLuint *v)) \
+    F(void, Color4ui, (GLuint red, GLuint green, GLuint blue, GLuint alpha)) \
+    F(void, Color4ubv, (const GLubyte *v)) \
+    F(void, Color4ub, (GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)) \
+    F(void, Color4sv, (const GLshort *v)) \
+    F(void, Color4s, (GLshort red, GLshort green, GLshort blue, GLshort alpha)) \
+    F(void, Color4iv, (const GLint *v)) \
+    F(void, Color4i, (GLint red, GLint green, GLint blue, GLint alpha)) \
+    F(void, Color4fv, (const GLfloat *v)) \
+    F(void, Color4f, (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)) \
+    F(void, Color4dv, (const GLdouble *v)) \
+    F(void, Color4d, (GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)) \
+    F(void, Color4bv, (const GLbyte *v)) \
+    F(void, Color4b, (GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)) \
+    F(void, Color3usv, (const GLushort *v)) \
+    F(void, Color3us, (GLushort red, GLushort green, GLushort blue)) \
+    F(void, Color3uiv, (const GLuint *v)) \
+    F(void, Color3ui, (GLuint red, GLuint green, GLuint blue)) \
+    F(void, Color3ubv, (const GLubyte *v)) \
+    F(void, Color3ub, (GLubyte red, GLubyte green, GLubyte blue)) \
+    F(void, Color3sv, (const GLshort *v)) \
+    F(void, Color3s, (GLshort red, GLshort green, GLshort blue)) \
+    F(void, Color3iv, (const GLint *v)) \
+    F(void, Color3i, (GLint red, GLint green, GLint blue)) \
+    F(void, Color3fv, (const GLfloat *v)) \
+    F(void, Color3f, (GLfloat red, GLfloat green, GLfloat blue)) \
+    F(void, Color3dv, (const GLdouble *v)) \
+    F(void, Color3d, (GLdouble red, GLdouble green, GLdouble blue)) \
+    F(void, Color3bv, (const GLbyte *v)) \
+    F(void, Color3b, (GLbyte red, GLbyte green, GLbyte blue)) \
+    F(void, Bitmap, (GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)) \
+    F(void, Begin, (GLenum mode)) \
+    F(void, ListBase, (GLuint base)) \
+    F(GLuint, GenLists, (GLsizei range)) \
+    F(void, DeleteLists, (GLuint list, GLsizei range)) \
+    F(void, CallLists, (GLsizei n, GLenum type, const GLvoid *lists)) \
+    F(void, CallList, (GLuint list)) \
+    F(void, EndList, ()) \
+    F(void, NewList, (GLuint list, GLenum mode)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_1_0_DEPRECATED_FUNCTIONS);
 };
 
 class QOpenGLFunctions_1_1_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_1_1_DeprecatedBackend(QOpenGLContext *context);
+    QOpenGLFunctions_1_1_DeprecatedBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_1_1_Deprecated; }
 
     // OpenGL 1.1 deprecated functions
-    void (QOPENGLF_APIENTRYP PushClientAttrib)(GLbitfield mask);
-    void (QOPENGLF_APIENTRYP PopClientAttrib)();
-    void (QOPENGLF_APIENTRYP PrioritizeTextures)(GLsizei n, const GLuint *textures, const GLfloat *priorities);
-    GLboolean (QOPENGLF_APIENTRYP AreTexturesResident)(GLsizei n, const GLuint *textures, GLboolean *residences);
-    void (QOPENGLF_APIENTRYP VertexPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void (QOPENGLF_APIENTRYP TexCoordPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void (QOPENGLF_APIENTRYP NormalPointer)(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void (QOPENGLF_APIENTRYP InterleavedArrays)(GLenum format, GLsizei stride, const GLvoid *pointer);
-    void (QOPENGLF_APIENTRYP IndexPointer)(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void (QOPENGLF_APIENTRYP EnableClientState)(GLenum array);
-    void (QOPENGLF_APIENTRYP EdgeFlagPointer)(GLsizei stride, const GLvoid *pointer);
-    void (QOPENGLF_APIENTRYP DisableClientState)(GLenum array);
-    void (QOPENGLF_APIENTRYP ColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void (QOPENGLF_APIENTRYP ArrayElement)(GLint i);
-    void (QOPENGLF_APIENTRYP Indexubv)(const GLubyte *c);
-    void (QOPENGLF_APIENTRYP Indexub)(GLubyte c);
-    void (QOPENGLF_APIENTRYP GetPointerv)(GLenum pname, GLvoid* *params);
+#define QT_OPENGL_1_1_DEPRECATED_FUNCTIONS(F) \
+    F(void, PushClientAttrib, (GLbitfield mask)) \
+    F(void, PopClientAttrib, ()) \
+    F(void, PrioritizeTextures, (GLsizei n, const GLuint *textures, const GLfloat *priorities)) \
+    F(GLboolean, AreTexturesResident, (GLsizei n, const GLuint *textures, GLboolean *residences)) \
+    F(void, VertexPointer, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)) \
+    F(void, TexCoordPointer, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)) \
+    F(void, NormalPointer, (GLenum type, GLsizei stride, const GLvoid *pointer)) \
+    F(void, InterleavedArrays, (GLenum format, GLsizei stride, const GLvoid *pointer)) \
+    F(void, IndexPointer, (GLenum type, GLsizei stride, const GLvoid *pointer)) \
+    F(void, EnableClientState, (GLenum array)) \
+    F(void, EdgeFlagPointer, (GLsizei stride, const GLvoid *pointer)) \
+    F(void, DisableClientState, (GLenum array)) \
+    F(void, ColorPointer, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)) \
+    F(void, ArrayElement, (GLint i)) \
+    F(void, Indexubv, (const GLubyte *c)) \
+    F(void, Indexub, (GLubyte c)) \
+    F(void, GetPointerv, (GLenum pname, GLvoid* *params)) \
+
+    QT_OPENGL_DECLARE(QT_OPENGL_1_1_DEPRECATED_FUNCTIONS);
 };
 
 class QOpenGLFunctions_1_2_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_1_2_DeprecatedBackend(QOpenGLContext *context);
+    QOpenGLFunctions_1_2_DeprecatedBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_1_2_Deprecated; }
 
     // OpenGL 1.2 deprecated functions
-    void (QOPENGLF_APIENTRYP ColorTableParameterfv)(GLenum target, GLenum pname, const GLfloat *params);
-    void (QOPENGLF_APIENTRYP ColorTableParameteriv)(GLenum target, GLenum pname, const GLint *params);
-    void (QOPENGLF_APIENTRYP CopyColorTable)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void (QOPENGLF_APIENTRYP GetColorTable)(GLenum target, GLenum format, GLenum type, GLvoid *table);
-    void (QOPENGLF_APIENTRYP GetColorTableParameterfv)(GLenum target, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetColorTableParameteriv)(GLenum target, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP ColorSubTable)(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data);
-    void (QOPENGLF_APIENTRYP CopyColorSubTable)(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width);
-    void (QOPENGLF_APIENTRYP ConvolutionFilter1D)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image);
-    void (QOPENGLF_APIENTRYP ConvolutionFilter2D)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image);
-    void (QOPENGLF_APIENTRYP ConvolutionParameterf)(GLenum target, GLenum pname, GLfloat params);
-    void (QOPENGLF_APIENTRYP ConvolutionParameterfv)(GLenum target, GLenum pname, const GLfloat *params);
-    void (QOPENGLF_APIENTRYP ConvolutionParameteri)(GLenum target, GLenum pname, GLint params);
-    void (QOPENGLF_APIENTRYP ConvolutionParameteriv)(GLenum target, GLenum pname, const GLint *params);
-    void (QOPENGLF_APIENTRYP CopyConvolutionFilter1D)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width);
-    void (QOPENGLF_APIENTRYP CopyConvolutionFilter2D)(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height);
-    void (QOPENGLF_APIENTRYP GetConvolutionFilter)(GLenum target, GLenum format, GLenum type, GLvoid *image);
-    void (QOPENGLF_APIENTRYP GetConvolutionParameterfv)(GLenum target, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetConvolutionParameteriv)(GLenum target, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetSeparableFilter)(GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span);
-    void (QOPENGLF_APIENTRYP SeparableFilter2D)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column);
-    void (QOPENGLF_APIENTRYP GetHistogram)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void (QOPENGLF_APIENTRYP GetHistogramParameterfv)(GLenum target, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetHistogramParameteriv)(GLenum target, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP GetMinmax)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values);
-    void (QOPENGLF_APIENTRYP GetMinmaxParameterfv)(GLenum target, GLenum pname, GLfloat *params);
-    void (QOPENGLF_APIENTRYP GetMinmaxParameteriv)(GLenum target, GLenum pname, GLint *params);
-    void (QOPENGLF_APIENTRYP Histogram)(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink);
-    void (QOPENGLF_APIENTRYP Minmax)(GLenum target, GLenum internalformat, GLboolean sink);
-    void (QOPENGLF_APIENTRYP ResetHistogram)(GLenum target);
-    void (QOPENGLF_APIENTRYP ResetMinmax)(GLenum target);
-    void (QOPENGLF_APIENTRYP ColorTable)(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table);
+#define QT_OPENGL_1_2_DEPRECATED_FUNCTIONS(F) \
+    F(void, ColorTableParameterfv, (GLenum target, GLenum pname, const GLfloat *params)) \
+    F(void, ColorTableParameteriv, (GLenum target, GLenum pname, const GLint *params)) \
+    F(void, CopyColorTable, (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)) \
+    F(void, GetColorTable, (GLenum target, GLenum format, GLenum type, GLvoid *table)) \
+    F(void, GetColorTableParameterfv, (GLenum target, GLenum pname, GLfloat *params)) \
+    F(void, GetColorTableParameteriv, (GLenum target, GLenum pname, GLint *params)) \
+    F(void, ColorSubTable, (GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const GLvoid *data)) \
+    F(void, CopyColorSubTable, (GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)) \
+    F(void, ConvolutionFilter1D, (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *image)) \
+    F(void, ConvolutionFilter2D, (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *image)) \
+    F(void, ConvolutionParameterf, (GLenum target, GLenum pname, GLfloat params)) \
+    F(void, ConvolutionParameterfv, (GLenum target, GLenum pname, const GLfloat *params)) \
+    F(void, ConvolutionParameteri, (GLenum target, GLenum pname, GLint params)) \
+    F(void, ConvolutionParameteriv, (GLenum target, GLenum pname, const GLint *params)) \
+    F(void, CopyConvolutionFilter1D, (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)) \
+    F(void, CopyConvolutionFilter2D, (GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)) \
+    F(void, GetConvolutionFilter, (GLenum target, GLenum format, GLenum type, GLvoid *image)) \
+    F(void, GetConvolutionParameterfv, (GLenum target, GLenum pname, GLfloat *params)) \
+    F(void, GetConvolutionParameteriv, (GLenum target, GLenum pname, GLint *params)) \
+    F(void, GetSeparableFilter, (GLenum target, GLenum format, GLenum type, GLvoid *row, GLvoid *column, GLvoid *span)) \
+    F(void, SeparableFilter2D, (GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *row, const GLvoid *column)) \
+    F(void, GetHistogram, (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)) \
+    F(void, GetHistogramParameterfv, (GLenum target, GLenum pname, GLfloat *params)) \
+    F(void, GetHistogramParameteriv, (GLenum target, GLenum pname, GLint *params)) \
+    F(void, GetMinmax, (GLenum target, GLboolean reset, GLenum format, GLenum type, GLvoid *values)) \
+    F(void, GetMinmaxParameterfv, (GLenum target, GLenum pname, GLfloat *params)) \
+    F(void, GetMinmaxParameteriv, (GLenum target, GLenum pname, GLint *params)) \
+    F(void, Histogram, (GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)) \
+    F(void, Minmax, (GLenum target, GLenum internalformat, GLboolean sink)) \
+    F(void, ResetHistogram, (GLenum target)) \
+    F(void, ResetMinmax, (GLenum target)) \
+    F(void, ColorTable, (GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const GLvoid *table)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_1_2_DEPRECATED_FUNCTIONS);
 };
 
 class QOpenGLFunctions_1_3_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_1_3_DeprecatedBackend(QOpenGLContext *context);
+    QOpenGLFunctions_1_3_DeprecatedBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_1_3_Deprecated; }
 
     // OpenGL 1.3 deprecated functions
-    void (QOPENGLF_APIENTRYP MultTransposeMatrixd)(const GLdouble *m);
-    void (QOPENGLF_APIENTRYP MultTransposeMatrixf)(const GLfloat *m);
-    void (QOPENGLF_APIENTRYP LoadTransposeMatrixd)(const GLdouble *m);
-    void (QOPENGLF_APIENTRYP LoadTransposeMatrixf)(const GLfloat *m);
-    void (QOPENGLF_APIENTRYP MultiTexCoord4sv)(GLenum target, const GLshort *v);
-    void (QOPENGLF_APIENTRYP MultiTexCoord4s)(GLenum target, GLshort s, GLshort t, GLshort r, GLshort q);
-    void (QOPENGLF_APIENTRYP MultiTexCoord4iv)(GLenum target, const GLint *v);
-    void (QOPENGLF_APIENTRYP MultiTexCoord4i)(GLenum target, GLint s, GLint t, GLint r, GLint q);
-    void (QOPENGLF_APIENTRYP MultiTexCoord4fv)(GLenum target, const GLfloat *v);
-    void (QOPENGLF_APIENTRYP MultiTexCoord4f)(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q);
-    void (QOPENGLF_APIENTRYP MultiTexCoord4dv)(GLenum target, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP MultiTexCoord4d)(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q);
-    void (QOPENGLF_APIENTRYP MultiTexCoord3sv)(GLenum target, const GLshort *v);
-    void (QOPENGLF_APIENTRYP MultiTexCoord3s)(GLenum target, GLshort s, GLshort t, GLshort r);
-    void (QOPENGLF_APIENTRYP MultiTexCoord3iv)(GLenum target, const GLint *v);
-    void (QOPENGLF_APIENTRYP MultiTexCoord3i)(GLenum target, GLint s, GLint t, GLint r);
-    void (QOPENGLF_APIENTRYP MultiTexCoord3fv)(GLenum target, const GLfloat *v);
-    void (QOPENGLF_APIENTRYP MultiTexCoord3f)(GLenum target, GLfloat s, GLfloat t, GLfloat r);
-    void (QOPENGLF_APIENTRYP MultiTexCoord3dv)(GLenum target, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP MultiTexCoord3d)(GLenum target, GLdouble s, GLdouble t, GLdouble r);
-    void (QOPENGLF_APIENTRYP MultiTexCoord2sv)(GLenum target, const GLshort *v);
-    void (QOPENGLF_APIENTRYP MultiTexCoord2s)(GLenum target, GLshort s, GLshort t);
-    void (QOPENGLF_APIENTRYP MultiTexCoord2iv)(GLenum target, const GLint *v);
-    void (QOPENGLF_APIENTRYP MultiTexCoord2i)(GLenum target, GLint s, GLint t);
-    void (QOPENGLF_APIENTRYP MultiTexCoord2fv)(GLenum target, const GLfloat *v);
-    void (QOPENGLF_APIENTRYP MultiTexCoord2f)(GLenum target, GLfloat s, GLfloat t);
-    void (QOPENGLF_APIENTRYP MultiTexCoord2dv)(GLenum target, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP MultiTexCoord2d)(GLenum target, GLdouble s, GLdouble t);
-    void (QOPENGLF_APIENTRYP MultiTexCoord1sv)(GLenum target, const GLshort *v);
-    void (QOPENGLF_APIENTRYP MultiTexCoord1s)(GLenum target, GLshort s);
-    void (QOPENGLF_APIENTRYP MultiTexCoord1iv)(GLenum target, const GLint *v);
-    void (QOPENGLF_APIENTRYP MultiTexCoord1i)(GLenum target, GLint s);
-    void (QOPENGLF_APIENTRYP MultiTexCoord1fv)(GLenum target, const GLfloat *v);
-    void (QOPENGLF_APIENTRYP MultiTexCoord1f)(GLenum target, GLfloat s);
-    void (QOPENGLF_APIENTRYP MultiTexCoord1dv)(GLenum target, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP MultiTexCoord1d)(GLenum target, GLdouble s);
-    void (QOPENGLF_APIENTRYP ClientActiveTexture)(GLenum texture);
+#define QT_OPENGL_1_3_DEPRECATED_FUNCTIONS(F) \
+    F(void, MultTransposeMatrixd, (const GLdouble *m)) \
+    F(void, MultTransposeMatrixf, (const GLfloat *m)) \
+    F(void, LoadTransposeMatrixd, (const GLdouble *m)) \
+    F(void, LoadTransposeMatrixf, (const GLfloat *m)) \
+    F(void, MultiTexCoord4sv, (GLenum target, const GLshort *v)) \
+    F(void, MultiTexCoord4s, (GLenum target, GLshort s, GLshort t, GLshort r, GLshort q)) \
+    F(void, MultiTexCoord4iv, (GLenum target, const GLint *v)) \
+    F(void, MultiTexCoord4i, (GLenum target, GLint s, GLint t, GLint r, GLint q)) \
+    F(void, MultiTexCoord4fv, (GLenum target, const GLfloat *v)) \
+    F(void, MultiTexCoord4f, (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)) \
+    F(void, MultiTexCoord4dv, (GLenum target, const GLdouble *v)) \
+    F(void, MultiTexCoord4d, (GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)) \
+    F(void, MultiTexCoord3sv, (GLenum target, const GLshort *v)) \
+    F(void, MultiTexCoord3s, (GLenum target, GLshort s, GLshort t, GLshort r)) \
+    F(void, MultiTexCoord3iv, (GLenum target, const GLint *v)) \
+    F(void, MultiTexCoord3i, (GLenum target, GLint s, GLint t, GLint r)) \
+    F(void, MultiTexCoord3fv, (GLenum target, const GLfloat *v)) \
+    F(void, MultiTexCoord3f, (GLenum target, GLfloat s, GLfloat t, GLfloat r)) \
+    F(void, MultiTexCoord3dv, (GLenum target, const GLdouble *v)) \
+    F(void, MultiTexCoord3d, (GLenum target, GLdouble s, GLdouble t, GLdouble r)) \
+    F(void, MultiTexCoord2sv, (GLenum target, const GLshort *v)) \
+    F(void, MultiTexCoord2s, (GLenum target, GLshort s, GLshort t)) \
+    F(void, MultiTexCoord2iv, (GLenum target, const GLint *v)) \
+    F(void, MultiTexCoord2i, (GLenum target, GLint s, GLint t)) \
+    F(void, MultiTexCoord2fv, (GLenum target, const GLfloat *v)) \
+    F(void, MultiTexCoord2f, (GLenum target, GLfloat s, GLfloat t)) \
+    F(void, MultiTexCoord2dv, (GLenum target, const GLdouble *v)) \
+    F(void, MultiTexCoord2d, (GLenum target, GLdouble s, GLdouble t)) \
+    F(void, MultiTexCoord1sv, (GLenum target, const GLshort *v)) \
+    F(void, MultiTexCoord1s, (GLenum target, GLshort s)) \
+    F(void, MultiTexCoord1iv, (GLenum target, const GLint *v)) \
+    F(void, MultiTexCoord1i, (GLenum target, GLint s)) \
+    F(void, MultiTexCoord1fv, (GLenum target, const GLfloat *v)) \
+    F(void, MultiTexCoord1f, (GLenum target, GLfloat s)) \
+    F(void, MultiTexCoord1dv, (GLenum target, const GLdouble *v)) \
+    F(void, MultiTexCoord1d, (GLenum target, GLdouble s)) \
+    F(void, ClientActiveTexture, (GLenum texture)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_1_3_DEPRECATED_FUNCTIONS);
 };
 
 class QOpenGLFunctions_1_4_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_1_4_DeprecatedBackend(QOpenGLContext *context);
+    QOpenGLFunctions_1_4_DeprecatedBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_1_4_Deprecated; }
 
     // OpenGL 1.4 deprecated functions
-    void (QOPENGLF_APIENTRYP WindowPos3sv)(const GLshort *v);
-    void (QOPENGLF_APIENTRYP WindowPos3s)(GLshort x, GLshort y, GLshort z);
-    void (QOPENGLF_APIENTRYP WindowPos3iv)(const GLint *v);
-    void (QOPENGLF_APIENTRYP WindowPos3i)(GLint x, GLint y, GLint z);
-    void (QOPENGLF_APIENTRYP WindowPos3fv)(const GLfloat *v);
-    void (QOPENGLF_APIENTRYP WindowPos3f)(GLfloat x, GLfloat y, GLfloat z);
-    void (QOPENGLF_APIENTRYP WindowPos3dv)(const GLdouble *v);
-    void (QOPENGLF_APIENTRYP WindowPos3d)(GLdouble x, GLdouble y, GLdouble z);
-    void (QOPENGLF_APIENTRYP WindowPos2sv)(const GLshort *v);
-    void (QOPENGLF_APIENTRYP WindowPos2s)(GLshort x, GLshort y);
-    void (QOPENGLF_APIENTRYP WindowPos2iv)(const GLint *v);
-    void (QOPENGLF_APIENTRYP WindowPos2i)(GLint x, GLint y);
-    void (QOPENGLF_APIENTRYP WindowPos2fv)(const GLfloat *v);
-    void (QOPENGLF_APIENTRYP WindowPos2f)(GLfloat x, GLfloat y);
-    void (QOPENGLF_APIENTRYP WindowPos2dv)(const GLdouble *v);
-    void (QOPENGLF_APIENTRYP WindowPos2d)(GLdouble x, GLdouble y);
-    void (QOPENGLF_APIENTRYP SecondaryColorPointer)(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer);
-    void (QOPENGLF_APIENTRYP SecondaryColor3usv)(const GLushort *v);
-    void (QOPENGLF_APIENTRYP SecondaryColor3us)(GLushort red, GLushort green, GLushort blue);
-    void (QOPENGLF_APIENTRYP SecondaryColor3uiv)(const GLuint *v);
-    void (QOPENGLF_APIENTRYP SecondaryColor3ui)(GLuint red, GLuint green, GLuint blue);
-    void (QOPENGLF_APIENTRYP SecondaryColor3ubv)(const GLubyte *v);
-    void (QOPENGLF_APIENTRYP SecondaryColor3ub)(GLubyte red, GLubyte green, GLubyte blue);
-    void (QOPENGLF_APIENTRYP SecondaryColor3sv)(const GLshort *v);
-    void (QOPENGLF_APIENTRYP SecondaryColor3s)(GLshort red, GLshort green, GLshort blue);
-    void (QOPENGLF_APIENTRYP SecondaryColor3iv)(const GLint *v);
-    void (QOPENGLF_APIENTRYP SecondaryColor3i)(GLint red, GLint green, GLint blue);
-    void (QOPENGLF_APIENTRYP SecondaryColor3fv)(const GLfloat *v);
-    void (QOPENGLF_APIENTRYP SecondaryColor3f)(GLfloat red, GLfloat green, GLfloat blue);
-    void (QOPENGLF_APIENTRYP SecondaryColor3dv)(const GLdouble *v);
-    void (QOPENGLF_APIENTRYP SecondaryColor3d)(GLdouble red, GLdouble green, GLdouble blue);
-    void (QOPENGLF_APIENTRYP SecondaryColor3bv)(const GLbyte *v);
-    void (QOPENGLF_APIENTRYP SecondaryColor3b)(GLbyte red, GLbyte green, GLbyte blue);
-    void (QOPENGLF_APIENTRYP FogCoordPointer)(GLenum type, GLsizei stride, const GLvoid *pointer);
-    void (QOPENGLF_APIENTRYP FogCoorddv)(const GLdouble *coord);
-    void (QOPENGLF_APIENTRYP FogCoordd)(GLdouble coord);
-    void (QOPENGLF_APIENTRYP FogCoordfv)(const GLfloat *coord);
-    void (QOPENGLF_APIENTRYP FogCoordf)(GLfloat coord);
+#define QT_OPENGL_1_4_DEPRECATED_FUNCTIONS(F) \
+    F(void, WindowPos3sv, (const GLshort *v)) \
+    F(void, WindowPos3s, (GLshort x, GLshort y, GLshort z)) \
+    F(void, WindowPos3iv, (const GLint *v)) \
+    F(void, WindowPos3i, (GLint x, GLint y, GLint z)) \
+    F(void, WindowPos3fv, (const GLfloat *v)) \
+    F(void, WindowPos3f, (GLfloat x, GLfloat y, GLfloat z)) \
+    F(void, WindowPos3dv, (const GLdouble *v)) \
+    F(void, WindowPos3d, (GLdouble x, GLdouble y, GLdouble z)) \
+    F(void, WindowPos2sv, (const GLshort *v)) \
+    F(void, WindowPos2s, (GLshort x, GLshort y)) \
+    F(void, WindowPos2iv, (const GLint *v)) \
+    F(void, WindowPos2i, (GLint x, GLint y)) \
+    F(void, WindowPos2fv, (const GLfloat *v)) \
+    F(void, WindowPos2f, (GLfloat x, GLfloat y)) \
+    F(void, WindowPos2dv, (const GLdouble *v)) \
+    F(void, WindowPos2d, (GLdouble x, GLdouble y)) \
+    F(void, SecondaryColorPointer, (GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)) \
+    F(void, SecondaryColor3usv, (const GLushort *v)) \
+    F(void, SecondaryColor3us, (GLushort red, GLushort green, GLushort blue)) \
+    F(void, SecondaryColor3uiv, (const GLuint *v)) \
+    F(void, SecondaryColor3ui, (GLuint red, GLuint green, GLuint blue)) \
+    F(void, SecondaryColor3ubv, (const GLubyte *v)) \
+    F(void, SecondaryColor3ub, (GLubyte red, GLubyte green, GLubyte blue)) \
+    F(void, SecondaryColor3sv, (const GLshort *v)) \
+    F(void, SecondaryColor3s, (GLshort red, GLshort green, GLshort blue)) \
+    F(void, SecondaryColor3iv, (const GLint *v)) \
+    F(void, SecondaryColor3i, (GLint red, GLint green, GLint blue)) \
+    F(void, SecondaryColor3fv, (const GLfloat *v)) \
+    F(void, SecondaryColor3f, (GLfloat red, GLfloat green, GLfloat blue)) \
+    F(void, SecondaryColor3dv, (const GLdouble *v)) \
+    F(void, SecondaryColor3d, (GLdouble red, GLdouble green, GLdouble blue)) \
+    F(void, SecondaryColor3bv, (const GLbyte *v)) \
+    F(void, SecondaryColor3b, (GLbyte red, GLbyte green, GLbyte blue)) \
+    F(void, FogCoordPointer, (GLenum type, GLsizei stride, const GLvoid *pointer)) \
+    F(void, FogCoorddv, (const GLdouble *coord)) \
+    F(void, FogCoordd, (GLdouble coord)) \
+    F(void, FogCoordfv, (const GLfloat *coord)) \
+    F(void, FogCoordf, (GLfloat coord)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_1_4_DEPRECATED_FUNCTIONS);
 };
 
 class QOpenGLFunctions_2_0_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_2_0_DeprecatedBackend(QOpenGLContext *context);
+    QOpenGLFunctions_2_0_DeprecatedBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_2_0_Deprecated; }
 
     // OpenGL 2.0 deprecated functions
-    void (QOPENGLF_APIENTRYP VertexAttrib4usv)(GLuint index, const GLushort *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4uiv)(GLuint index, const GLuint *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4ubv)(GLuint index, const GLubyte *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4sv)(GLuint index, const GLshort *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4s)(GLuint index, GLshort x, GLshort y, GLshort z, GLshort w);
-    void (QOPENGLF_APIENTRYP VertexAttrib4iv)(GLuint index, const GLint *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4fv)(GLuint index, const GLfloat *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4f)(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void (QOPENGLF_APIENTRYP VertexAttrib4dv)(GLuint index, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4d)(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w);
-    void (QOPENGLF_APIENTRYP VertexAttrib4bv)(GLuint index, const GLbyte *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4Nusv)(GLuint index, const GLushort *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4Nuiv)(GLuint index, const GLuint *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4Nubv)(GLuint index, const GLubyte *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4Nub)(GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w);
-    void (QOPENGLF_APIENTRYP VertexAttrib4Nsv)(GLuint index, const GLshort *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4Niv)(GLuint index, const GLint *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib4Nbv)(GLuint index, const GLbyte *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib3sv)(GLuint index, const GLshort *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib3s)(GLuint index, GLshort x, GLshort y, GLshort z);
-    void (QOPENGLF_APIENTRYP VertexAttrib3fv)(GLuint index, const GLfloat *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib3f)(GLuint index, GLfloat x, GLfloat y, GLfloat z);
-    void (QOPENGLF_APIENTRYP VertexAttrib3dv)(GLuint index, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib3d)(GLuint index, GLdouble x, GLdouble y, GLdouble z);
-    void (QOPENGLF_APIENTRYP VertexAttrib2sv)(GLuint index, const GLshort *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib2s)(GLuint index, GLshort x, GLshort y);
-    void (QOPENGLF_APIENTRYP VertexAttrib2fv)(GLuint index, const GLfloat *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib2f)(GLuint index, GLfloat x, GLfloat y);
-    void (QOPENGLF_APIENTRYP VertexAttrib2dv)(GLuint index, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib2d)(GLuint index, GLdouble x, GLdouble y);
-    void (QOPENGLF_APIENTRYP VertexAttrib1sv)(GLuint index, const GLshort *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib1s)(GLuint index, GLshort x);
-    void (QOPENGLF_APIENTRYP VertexAttrib1fv)(GLuint index, const GLfloat *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib1f)(GLuint index, GLfloat x);
-    void (QOPENGLF_APIENTRYP VertexAttrib1dv)(GLuint index, const GLdouble *v);
-    void (QOPENGLF_APIENTRYP VertexAttrib1d)(GLuint index, GLdouble x);
+#define QT_OPENGL_2_0_DEPRECATED_FUNCTIONS(F) \
+    F(void, VertexAttrib4usv, (GLuint index, const GLushort *v)) \
+    F(void, VertexAttrib4uiv, (GLuint index, const GLuint *v)) \
+    F(void, VertexAttrib4ubv, (GLuint index, const GLubyte *v)) \
+    F(void, VertexAttrib4sv, (GLuint index, const GLshort *v)) \
+    F(void, VertexAttrib4s, (GLuint index, GLshort x, GLshort y, GLshort z, GLshort w)) \
+    F(void, VertexAttrib4iv, (GLuint index, const GLint *v)) \
+    F(void, VertexAttrib4fv, (GLuint index, const GLfloat *v)) \
+    F(void, VertexAttrib4f, (GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)) \
+    F(void, VertexAttrib4dv, (GLuint index, const GLdouble *v)) \
+    F(void, VertexAttrib4d, (GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)) \
+    F(void, VertexAttrib4bv, (GLuint index, const GLbyte *v)) \
+    F(void, VertexAttrib4Nusv, (GLuint index, const GLushort *v)) \
+    F(void, VertexAttrib4Nuiv, (GLuint index, const GLuint *v)) \
+    F(void, VertexAttrib4Nubv, (GLuint index, const GLubyte *v)) \
+    F(void, VertexAttrib4Nub, (GLuint index, GLubyte x, GLubyte y, GLubyte z, GLubyte w)) \
+    F(void, VertexAttrib4Nsv, (GLuint index, const GLshort *v)) \
+    F(void, VertexAttrib4Niv, (GLuint index, const GLint *v)) \
+    F(void, VertexAttrib4Nbv, (GLuint index, const GLbyte *v)) \
+    F(void, VertexAttrib3sv, (GLuint index, const GLshort *v)) \
+    F(void, VertexAttrib3s, (GLuint index, GLshort x, GLshort y, GLshort z)) \
+    F(void, VertexAttrib3fv, (GLuint index, const GLfloat *v)) \
+    F(void, VertexAttrib3f, (GLuint index, GLfloat x, GLfloat y, GLfloat z)) \
+    F(void, VertexAttrib3dv, (GLuint index, const GLdouble *v)) \
+    F(void, VertexAttrib3d, (GLuint index, GLdouble x, GLdouble y, GLdouble z)) \
+    F(void, VertexAttrib2sv, (GLuint index, const GLshort *v)) \
+    F(void, VertexAttrib2s, (GLuint index, GLshort x, GLshort y)) \
+    F(void, VertexAttrib2fv, (GLuint index, const GLfloat *v)) \
+    F(void, VertexAttrib2f, (GLuint index, GLfloat x, GLfloat y)) \
+    F(void, VertexAttrib2dv, (GLuint index, const GLdouble *v)) \
+    F(void, VertexAttrib2d, (GLuint index, GLdouble x, GLdouble y)) \
+    F(void, VertexAttrib1sv, (GLuint index, const GLshort *v)) \
+    F(void, VertexAttrib1s, (GLuint index, GLshort x)) \
+    F(void, VertexAttrib1fv, (GLuint index, const GLfloat *v)) \
+    F(void, VertexAttrib1f, (GLuint index, GLfloat x)) \
+    F(void, VertexAttrib1dv, (GLuint index, const GLdouble *v)) \
+    F(void, VertexAttrib1d, (GLuint index, GLdouble x)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_2_0_DEPRECATED_FUNCTIONS);
 };
 
 class QOpenGLFunctions_3_0_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_3_0_DeprecatedBackend(QOpenGLContext *context);
+    QOpenGLFunctions_3_0_DeprecatedBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_3_0_Deprecated; }
 
     // OpenGL 3.0 deprecated functions
-    void (QOPENGLF_APIENTRYP VertexAttribI4usv)(GLuint index, const GLushort *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI4ubv)(GLuint index, const GLubyte *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI4sv)(GLuint index, const GLshort *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI4bv)(GLuint index, const GLbyte *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI4uiv)(GLuint index, const GLuint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI3uiv)(GLuint index, const GLuint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI2uiv)(GLuint index, const GLuint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI1uiv)(GLuint index, const GLuint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI4iv)(GLuint index, const GLint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI3iv)(GLuint index, const GLint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI2iv)(GLuint index, const GLint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI1iv)(GLuint index, const GLint *v);
-    void (QOPENGLF_APIENTRYP VertexAttribI4ui)(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w);
-    void (QOPENGLF_APIENTRYP VertexAttribI3ui)(GLuint index, GLuint x, GLuint y, GLuint z);
-    void (QOPENGLF_APIENTRYP VertexAttribI2ui)(GLuint index, GLuint x, GLuint y);
-    void (QOPENGLF_APIENTRYP VertexAttribI1ui)(GLuint index, GLuint x);
-    void (QOPENGLF_APIENTRYP VertexAttribI4i)(GLuint index, GLint x, GLint y, GLint z, GLint w);
-    void (QOPENGLF_APIENTRYP VertexAttribI3i)(GLuint index, GLint x, GLint y, GLint z);
-    void (QOPENGLF_APIENTRYP VertexAttribI2i)(GLuint index, GLint x, GLint y);
-    void (QOPENGLF_APIENTRYP VertexAttribI1i)(GLuint index, GLint x);
+#define QT_OPENGL_3_0_DEPRECATED_FUNCTIONS(F) \
+    F(void, VertexAttribI4usv, (GLuint index, const GLushort *v)) \
+    F(void, VertexAttribI4ubv, (GLuint index, const GLubyte *v)) \
+    F(void, VertexAttribI4sv, (GLuint index, const GLshort *v)) \
+    F(void, VertexAttribI4bv, (GLuint index, const GLbyte *v)) \
+    F(void, VertexAttribI4uiv, (GLuint index, const GLuint *v)) \
+    F(void, VertexAttribI3uiv, (GLuint index, const GLuint *v)) \
+    F(void, VertexAttribI2uiv, (GLuint index, const GLuint *v)) \
+    F(void, VertexAttribI1uiv, (GLuint index, const GLuint *v)) \
+    F(void, VertexAttribI4iv, (GLuint index, const GLint *v)) \
+    F(void, VertexAttribI3iv, (GLuint index, const GLint *v)) \
+    F(void, VertexAttribI2iv, (GLuint index, const GLint *v)) \
+    F(void, VertexAttribI1iv, (GLuint index, const GLint *v)) \
+    F(void, VertexAttribI4ui, (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)) \
+    F(void, VertexAttribI3ui, (GLuint index, GLuint x, GLuint y, GLuint z)) \
+    F(void, VertexAttribI2ui, (GLuint index, GLuint x, GLuint y)) \
+    F(void, VertexAttribI1ui, (GLuint index, GLuint x)) \
+    F(void, VertexAttribI4i, (GLuint index, GLint x, GLint y, GLint z, GLint w)) \
+    F(void, VertexAttribI3i, (GLuint index, GLint x, GLint y, GLint z)) \
+    F(void, VertexAttribI2i, (GLuint index, GLint x, GLint y)) \
+    F(void, VertexAttribI1i, (GLuint index, GLint x)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_3_0_DEPRECATED_FUNCTIONS);
 };
 
 class QOpenGLFunctions_3_3_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_3_3_DeprecatedBackend(QOpenGLContext *context);
+    QOpenGLFunctions_3_3_DeprecatedBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_3_3_Deprecated; }
 
     // OpenGL 3.3 deprecated functions
-    void (QOPENGLF_APIENTRYP SecondaryColorP3uiv)(GLenum type, const GLuint *color);
-    void (QOPENGLF_APIENTRYP SecondaryColorP3ui)(GLenum type, GLuint color);
-    void (QOPENGLF_APIENTRYP ColorP4uiv)(GLenum type, const GLuint *color);
-    void (QOPENGLF_APIENTRYP ColorP4ui)(GLenum type, GLuint color);
-    void (QOPENGLF_APIENTRYP ColorP3uiv)(GLenum type, const GLuint *color);
-    void (QOPENGLF_APIENTRYP ColorP3ui)(GLenum type, GLuint color);
-    void (QOPENGLF_APIENTRYP NormalP3uiv)(GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP NormalP3ui)(GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP MultiTexCoordP4uiv)(GLenum texture, GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP MultiTexCoordP4ui)(GLenum texture, GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP MultiTexCoordP3uiv)(GLenum texture, GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP MultiTexCoordP3ui)(GLenum texture, GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP MultiTexCoordP2uiv)(GLenum texture, GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP MultiTexCoordP2ui)(GLenum texture, GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP MultiTexCoordP1uiv)(GLenum texture, GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP MultiTexCoordP1ui)(GLenum texture, GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP TexCoordP4uiv)(GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP TexCoordP4ui)(GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP TexCoordP3uiv)(GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP TexCoordP3ui)(GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP TexCoordP2uiv)(GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP TexCoordP2ui)(GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP TexCoordP1uiv)(GLenum type, const GLuint *coords);
-    void (QOPENGLF_APIENTRYP TexCoordP1ui)(GLenum type, GLuint coords);
-    void (QOPENGLF_APIENTRYP VertexP4uiv)(GLenum type, const GLuint *value);
-    void (QOPENGLF_APIENTRYP VertexP4ui)(GLenum type, GLuint value);
-    void (QOPENGLF_APIENTRYP VertexP3uiv)(GLenum type, const GLuint *value);
-    void (QOPENGLF_APIENTRYP VertexP3ui)(GLenum type, GLuint value);
-    void (QOPENGLF_APIENTRYP VertexP2uiv)(GLenum type, const GLuint *value);
-    void (QOPENGLF_APIENTRYP VertexP2ui)(GLenum type, GLuint value);
+#define QT_OPENGL_3_3_DEPRECATED_FUNCTIONS(F) \
+    F(void, SecondaryColorP3uiv, (GLenum type, const GLuint *color)) \
+    F(void, SecondaryColorP3ui, (GLenum type, GLuint color)) \
+    F(void, ColorP4uiv, (GLenum type, const GLuint *color)) \
+    F(void, ColorP4ui, (GLenum type, GLuint color)) \
+    F(void, ColorP3uiv, (GLenum type, const GLuint *color)) \
+    F(void, ColorP3ui, (GLenum type, GLuint color)) \
+    F(void, NormalP3uiv, (GLenum type, const GLuint *coords)) \
+    F(void, NormalP3ui, (GLenum type, GLuint coords)) \
+    F(void, MultiTexCoordP4uiv, (GLenum texture, GLenum type, const GLuint *coords)) \
+    F(void, MultiTexCoordP4ui, (GLenum texture, GLenum type, GLuint coords)) \
+    F(void, MultiTexCoordP3uiv, (GLenum texture, GLenum type, const GLuint *coords)) \
+    F(void, MultiTexCoordP3ui, (GLenum texture, GLenum type, GLuint coords)) \
+    F(void, MultiTexCoordP2uiv, (GLenum texture, GLenum type, const GLuint *coords)) \
+    F(void, MultiTexCoordP2ui, (GLenum texture, GLenum type, GLuint coords)) \
+    F(void, MultiTexCoordP1uiv, (GLenum texture, GLenum type, const GLuint *coords)) \
+    F(void, MultiTexCoordP1ui, (GLenum texture, GLenum type, GLuint coords)) \
+    F(void, TexCoordP4uiv, (GLenum type, const GLuint *coords)) \
+    F(void, TexCoordP4ui, (GLenum type, GLuint coords)) \
+    F(void, TexCoordP3uiv, (GLenum type, const GLuint *coords)) \
+    F(void, TexCoordP3ui, (GLenum type, GLuint coords)) \
+    F(void, TexCoordP2uiv, (GLenum type, const GLuint *coords)) \
+    F(void, TexCoordP2ui, (GLenum type, GLuint coords)) \
+    F(void, TexCoordP1uiv, (GLenum type, const GLuint *coords)) \
+    F(void, TexCoordP1ui, (GLenum type, GLuint coords)) \
+    F(void, VertexP4uiv, (GLenum type, const GLuint *value)) \
+    F(void, VertexP4ui, (GLenum type, GLuint value)) \
+    F(void, VertexP3uiv, (GLenum type, const GLuint *value)) \
+    F(void, VertexP3ui, (GLenum type, GLuint value)) \
+    F(void, VertexP2uiv, (GLenum type, const GLuint *value)) \
+    F(void, VertexP2ui, (GLenum type, GLuint value)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_3_3_DEPRECATED_FUNCTIONS);
 };
 
 class QOpenGLFunctions_4_5_DeprecatedBackend : public QOpenGLVersionFunctionsBackend
 {
 public:
-    QOpenGLFunctions_4_5_DeprecatedBackend(QOpenGLContext *context);
+    QOpenGLFunctions_4_5_DeprecatedBackend(QOpenGLContext *c)
+        : QOpenGLVersionFunctionsBackend(c)
+    {
+        init();
+    }
 
-    static QOpenGLVersionStatus versionStatus();
+    Q_DECL_CONSTEXPR static Version versionStatus()
+    { return OpenGL_4_5_Deprecated; }
 
     // OpenGL 4.5 deprecated functions
-    void (QOPENGLF_APIENTRYP GetnMinmax)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid *values);
-    void (QOPENGLF_APIENTRYP GetnHistogram)(GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid *values);
-    void (QOPENGLF_APIENTRYP GetnSeparableFilter)(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, GLvoid *row, GLsizei columnBufSize, GLvoid *column, GLvoid *span);
-    void (QOPENGLF_APIENTRYP GetnConvolutionFilter)(GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid *image);
-    void (QOPENGLF_APIENTRYP GetnColorTable)(GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid *table);
-    void (QOPENGLF_APIENTRYP GetnPolygonStipple)(GLsizei bufSize, GLubyte *pattern);
-    void (QOPENGLF_APIENTRYP GetnPixelMapusv)(GLenum map, GLsizei bufSize, GLushort *values);
-    void (QOPENGLF_APIENTRYP GetnPixelMapuiv)(GLenum map, GLsizei bufSize, GLuint *values);
-    void (QOPENGLF_APIENTRYP GetnPixelMapfv)(GLenum map, GLsizei bufSize, GLfloat *values);
-    void (QOPENGLF_APIENTRYP GetnMapiv)(GLenum target, GLenum query, GLsizei bufSize, GLint *v);
-    void (QOPENGLF_APIENTRYP GetnMapfv)(GLenum target, GLenum query, GLsizei bufSize, GLfloat *v);
-    void (QOPENGLF_APIENTRYP GetnMapdv)(GLenum target, GLenum query, GLsizei bufSize, GLdouble *v);
+#define QT_OPENGL_4_5_DEPRECATED_FUNCTIONS(F) \
+    F(void, GetnMinmax, (GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid *values)) \
+    F(void, GetnHistogram, (GLenum target, GLboolean reset, GLenum format, GLenum type, GLsizei bufSize, GLvoid *values)) \
+    F(void, GetnSeparableFilter, (GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, GLvoid *row, GLsizei columnBufSize, GLvoid *column, GLvoid *span)) \
+    F(void, GetnConvolutionFilter, (GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid *image)) \
+    F(void, GetnColorTable, (GLenum target, GLenum format, GLenum type, GLsizei bufSize, GLvoid *table)) \
+    F(void, GetnPolygonStipple, (GLsizei bufSize, GLubyte *pattern)) \
+    F(void, GetnPixelMapusv, (GLenum map, GLsizei bufSize, GLushort *values)) \
+    F(void, GetnPixelMapuiv, (GLenum map, GLsizei bufSize, GLuint *values)) \
+    F(void, GetnPixelMapfv, (GLenum map, GLsizei bufSize, GLfloat *values)) \
+    F(void, GetnMapiv, (GLenum target, GLenum query, GLsizei bufSize, GLint *v)) \
+    F(void, GetnMapfv, (GLenum target, GLenum query, GLsizei bufSize, GLfloat *v)) \
+    F(void, GetnMapdv, (GLenum target, GLenum query, GLsizei bufSize, GLdouble *v)) \
 
+    QT_OPENGL_DECLARE(QT_OPENGL_4_5_DEPRECATED_FUNCTIONS);
 };
 
 #else
@@ -1638,6 +1889,11 @@ public:
 
 #endif // !QT_OPENGL_ES_2
 
+#undef QT_OPENGL_DECLARE_FUNCTIONS
+#undef QT_OPENGL_COUNT_FUNCTIONS
+#undef QT_OPENGL_DECLARE
+
+
 QT_END_NAMESPACE
 
 #endif // QT_NO_OPENGL
diff --git a/src/gui/opengl/qopenglvertexarrayobject.cpp b/src/gui/opengl/qopenglvertexarrayobject.cpp
index 8e0b536909b..6753064a605 100644
--- a/src/gui/opengl/qopenglvertexarrayobject.cpp
+++ b/src/gui/opengl/qopenglvertexarrayobject.cpp
@@ -63,33 +63,33 @@ void qtInitializeVertexArrayObjectHelper(QOpenGLVertexArrayObjectHelper *helper,
 
     if (context->isOpenGLES()) {
         if (context->format().majorVersion() >= 3) {
-            QOpenGLES3Helper *es3 = static_cast<QOpenGLExtensions *>(context->functions())->gles3Helper();
-            helper->GenVertexArrays = es3->GenVertexArrays;
-            helper->DeleteVertexArrays = es3->DeleteVertexArrays;
-            helper->BindVertexArray = es3->BindVertexArray;
-            helper->IsVertexArray = es3->IsVertexArray;
+            QOpenGLExtraFunctionsPrivate *extra = static_cast<QOpenGLExtensions *>(context->extraFunctions())->d();
+            helper->GenVertexArrays = extra->f.GenVertexArrays;
+            helper->DeleteVertexArrays = extra->f.DeleteVertexArrays;
+            helper->BindVertexArray = extra->f.BindVertexArray;
+            helper->IsVertexArray = extra->f.IsVertexArray;
             tryARB = false;
         } else if (context->hasExtension(QByteArrayLiteral("GL_OES_vertex_array_object"))) {
-            helper->GenVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_GenVertexArrays_t>(context->getProcAddress(QByteArrayLiteral("glGenVertexArraysOES")));
-            helper->DeleteVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_DeleteVertexArrays_t>(context->getProcAddress(QByteArrayLiteral("glDeleteVertexArraysOES")));
-            helper->BindVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_BindVertexArray_t>(context->getProcAddress(QByteArrayLiteral("glBindVertexArrayOES")));
-            helper->IsVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_IsVertexArray_t>(context->getProcAddress(QByteArrayLiteral("glIsVertexArrayOES")));
+            helper->GenVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_GenVertexArrays_t>(context->getProcAddress("glGenVertexArraysOES"));
+            helper->DeleteVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_DeleteVertexArrays_t>(context->getProcAddress("glDeleteVertexArraysOES"));
+            helper->BindVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_BindVertexArray_t>(context->getProcAddress("glBindVertexArrayOES"));
+            helper->IsVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_IsVertexArray_t>(context->getProcAddress("glIsVertexArrayOES"));
             tryARB = false;
         }
     } else if (context->hasExtension(QByteArrayLiteral("GL_APPLE_vertex_array_object")) &&
                !context->hasExtension(QByteArrayLiteral("GL_ARB_vertex_array_object"))) {
-        helper->GenVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_GenVertexArrays_t>(context->getProcAddress(QByteArrayLiteral("glGenVertexArraysAPPLE")));
-        helper->DeleteVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_DeleteVertexArrays_t>(context->getProcAddress(QByteArrayLiteral("glDeleteVertexArraysAPPLE")));
-        helper->BindVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_BindVertexArray_t>(context->getProcAddress(QByteArrayLiteral("glBindVertexArrayAPPLE")));
-        helper->IsVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_IsVertexArray_t>(context->getProcAddress(QByteArrayLiteral("glIsVertexArrayAPPLE")));
+        helper->GenVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_GenVertexArrays_t>(context->getProcAddress("glGenVertexArraysAPPLE"));
+        helper->DeleteVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_DeleteVertexArrays_t>(context->getProcAddress("glDeleteVertexArraysAPPLE"));
+        helper->BindVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_BindVertexArray_t>(context->getProcAddress("glBindVertexArrayAPPLE"));
+        helper->IsVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_IsVertexArray_t>(context->getProcAddress("glIsVertexArrayAPPLE"));
         tryARB = false;
     }
 
     if (tryARB && context->hasExtension(QByteArrayLiteral("GL_ARB_vertex_array_object"))) {
-        helper->GenVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_GenVertexArrays_t>(context->getProcAddress(QByteArrayLiteral("glGenVertexArrays")));
-        helper->DeleteVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_DeleteVertexArrays_t>(context->getProcAddress(QByteArrayLiteral("glDeleteVertexArrays")));
-        helper->BindVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_BindVertexArray_t>(context->getProcAddress(QByteArrayLiteral("glBindVertexArray")));
-        helper->IsVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_IsVertexArray_t>(context->getProcAddress(QByteArrayLiteral("glIsVertexArray")));
+        helper->GenVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_GenVertexArrays_t>(context->getProcAddress("glGenVertexArrays"));
+        helper->DeleteVertexArrays = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_DeleteVertexArrays_t>(context->getProcAddress("glDeleteVertexArrays"));
+        helper->BindVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_BindVertexArray_t>(context->getProcAddress("glBindVertexArray"));
+        helper->IsVertexArray = reinterpret_cast<QOpenGLVertexArrayObjectHelper::qt_IsVertexArray_t>(context->getProcAddress("glIsVertexArray"));
     }
 }
 
diff --git a/src/gui/painting/qcosmeticstroker.cpp b/src/gui/painting/qcosmeticstroker.cpp
index 5cbcdf83d47..4965762d741 100644
--- a/src/gui/painting/qcosmeticstroker.cpp
+++ b/src/gui/painting/qcosmeticstroker.cpp
@@ -68,8 +68,8 @@ static inline uint sourceOver(uint d, uint color)
 inline static int F16Dot16FixedDiv(int x, int y)
 {
     if (qAbs(x) > 0x7fff)
-        return (((qlonglong)x) << 16) / y;
-    return (x << 16) / y;
+        return qlonglong(x) * (1<<16) / y;
+    return x * (1<<16) / y;
 }
 
 typedef void (*DrawPixel)(QCosmeticStroker *stroker, int x, int y, int coverage);
@@ -147,12 +147,14 @@ inline void drawPixel(QCosmeticStroker *stroker, int x, int y, int coverage)
     if (x < cl.x() || x > cl.right() || y < cl.y() || y > cl.bottom())
         return;
 
-    int lastx = stroker->spans[stroker->current_span-1].x + stroker->spans[stroker->current_span-1].len ;
-    int lasty = stroker->spans[stroker->current_span-1].y;
+    if (stroker->current_span > 0) {
+        const int lastx = stroker->spans[stroker->current_span-1].x + stroker->spans[stroker->current_span-1].len ;
+        const int lasty = stroker->spans[stroker->current_span-1].y;
 
-    if (stroker->current_span == QCosmeticStroker::NSPANS || y < lasty || (y == lasty && x < lastx)) {
-        stroker->blend(stroker->current_span, stroker->spans, &stroker->state->penData);
-        stroker->current_span = 0;
+        if (stroker->current_span == QCosmeticStroker::NSPANS || y < lasty || (y == lasty && x < lastx)) {
+            stroker->blend(stroker->current_span, stroker->spans, &stroker->state->penData);
+            stroker->current_span = 0;
+        }
     }
 
     stroker->spans[stroker->current_span].x = ushort(x);
@@ -439,14 +441,14 @@ void QCosmeticStroker::calculateLastPoint(qreal rx1, qreal ry1, qreal rx2, qreal
             qSwap(x1, x2);
         }
         int xinc = F16Dot16FixedDiv(x2 - x1, y2 - y1);
-        int x = x1 << 10;
+        int x = x1 * (1<<10);
 
         int y = (y1 + 32) >> 6;
         int ys = (y2 + 32) >> 6;
 
         int round = (xinc > 0) ? 32 : 0;
         if (y != ys) {
-            x += ( ((((y << 6) + round - y1)))  * xinc ) >> 6;
+            x += ((y * (1<<6)) + round - y1) * xinc >> 6;
 
             if (swapped) {
                 lastPixel.x = x >> 16;
@@ -478,7 +480,7 @@ void QCosmeticStroker::calculateLastPoint(qreal rx1, qreal ry1, qreal rx2, qreal
 
         int round = (yinc > 0) ? 32 : 0;
         if (x != xs) {
-            y += ( ((((x << 6) + round - x1)))  * yinc ) >> 6;
+            y += ((x * (1<<6)) + round - x1) * yinc >> 6;
 
             if (swapped) {
                 lastPixel.x = x;
@@ -757,7 +759,7 @@ static bool drawLine(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx2,
             dir = QCosmeticStroker::BottomToTop;
         }
         int xinc = F16Dot16FixedDiv(x2 - x1, y2 - y1);
-        int x = x1 << 10;
+        int x = x1 * (1<<10);
 
         if ((stroker->lastDir ^ QCosmeticStroker::VerticalMask) == dir)
             caps |= swapped ? QCosmeticStroker::CapEnd : QCosmeticStroker::CapBegin;
@@ -769,7 +771,7 @@ static bool drawLine(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx2,
         int round = (xinc > 0) ? 32 : 0;
 
         if (y != ys) {
-            x += ( ((((y << 6) + round - y1)))  * xinc ) >> 6;
+            x += ((y * (1<<6)) + round - y1) * xinc >> 6;
 
             // calculate first and last pixel and perform dropout control
             QCosmeticStroker::Point first;
@@ -808,7 +810,7 @@ static bool drawLine(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx2,
             stroker->lastDir = dir;
             stroker->lastAxisAligned = axisAligned;
 
-            Dasher dasher(stroker, swapped, y << 6, ys << 6);
+            Dasher dasher(stroker, swapped, y * (1<<6), ys * (1<<6));
 
             do {
                 if (dasher.on())
@@ -834,7 +836,7 @@ static bool drawLine(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx2,
             dir = QCosmeticStroker::RightToLeft;
         }
         int yinc = F16Dot16FixedDiv(y2 - y1, x2 - x1);
-        int y = y1 << 10;
+        int y = y1 * (1<<10);
 
         if ((stroker->lastDir ^ QCosmeticStroker::HorizontalMask) == dir)
             caps |= swapped ? QCosmeticStroker::CapEnd : QCosmeticStroker::CapBegin;
@@ -846,7 +848,7 @@ static bool drawLine(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx2,
         int round = (yinc > 0) ? 32 : 0;
 
         if (x != xs) {
-            y += ( ((((x << 6) + round - x1)))  * yinc ) >> 6;
+            y += ((x * (1<<6)) + round - x1) * yinc >> 6;
 
             // calculate first and last pixel to perform dropout control
             QCosmeticStroker::Point first;
@@ -884,7 +886,7 @@ static bool drawLine(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx2,
             stroker->lastDir = dir;
             stroker->lastAxisAligned = axisAligned;
 
-            Dasher dasher(stroker, swapped, x << 6, xs << 6);
+            Dasher dasher(stroker, swapped, x * (1<<6), xs * (1<<6));
 
             do {
                 if (dasher.on())
@@ -927,7 +929,7 @@ static bool drawLineAA(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx
             caps = swapCaps(caps);
         }
 
-        int x = (x1 - 32) << 10;
+        int x = (x1 - 32) * (1<<10);
         x -= ( ((y1 & 63) - 32)  * xinc ) >> 6;
 
         capAdjust(caps, y1, y2, x, xinc);
@@ -990,7 +992,7 @@ static bool drawLineAA(QCosmeticStroker *stroker, qreal rx1, qreal ry1, qreal rx
             caps = swapCaps(caps);
         }
 
-        int y = (y1 - 32) << 10;
+        int y = (y1 - 32) * (1<<10);
         y -= ( ((x1 & 63) - 32)  * yinc ) >> 6;
 
         capAdjust(caps, x1, x2, y, yinc);
diff --git a/src/gui/painting/qdrawhelper.cpp b/src/gui/painting/qdrawhelper.cpp
index f60e49f699e..29c3ba3480a 100644
--- a/src/gui/painting/qdrawhelper.cpp
+++ b/src/gui/painting/qdrawhelper.cpp
@@ -135,10 +135,20 @@ template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_ARGB4444_Premultiplied
 template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_ARGB8555_Premultiplied>() { return 8; }
 template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_ARGB8565_Premultiplied>() { return 8; }
 template<> Q_DECL_CONSTEXPR uint blueShift<QImage::Format_ARGB6666_Premultiplied>() { return 0; }
+template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_RGB16>() { return 0; }
+template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_RGB444>() { return 0; }
+template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_RGB555>() { return 0; }
+template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_RGB666>() { return 0; }
+template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_RGB888>() { return 0; }
 template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_ARGB4444_Premultiplied>() { return  4; }
 template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_ARGB8555_Premultiplied>() { return  8; }
 template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_ARGB8565_Premultiplied>() { return  8; }
 template<> Q_DECL_CONSTEXPR uint alphaWidth<QImage::Format_ARGB6666_Premultiplied>() { return  6; }
+template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_RGB16>() { return 0; }
+template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_RGB444>() { return 0; }
+template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_RGB555>() { return 0; }
+template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_RGB666>() { return 0; }
+template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_RGB888>() { return 0; }
 template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_ARGB4444_Premultiplied>() { return 12; }
 template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_ARGB8555_Premultiplied>() { return  0; }
 template<> Q_DECL_CONSTEXPR uint alphaShift<QImage::Format_ARGB8565_Premultiplied>() { return  0; }
@@ -235,17 +245,36 @@ static const uint *QT_FASTCALL convertARGBPMToARGB32PM(uint *buffer, const uint
     Q_CONSTEXPR uchar greenRightShift = 2 * greenWidth<Format>() - 8;
     Q_CONSTEXPR uchar blueRightShift = 2 * blueWidth<Format>() - 8;
 
-    for (int i = 0; i < count; ++i) {
-        uint alpha = (src[i] >> alphaShift<Format>()) & alphaMask;
-        uint red = (src[i] >> redShift<Format>()) & redMask;
-        uint green = (src[i] >> greenShift<Format>()) & greenMask;
-        uint blue = (src[i] >> blueShift<Format>()) & blueMask;
+    Q_CONSTEXPR bool mustMin = (alphaWidth<Format>() != redWidth<Format>()) ||
+                               (alphaWidth<Format>() != greenWidth<Format>()) ||
+                               (alphaWidth<Format>() != blueWidth<Format>());
 
-        alpha = (alpha << alphaLeftShift) | (alpha >> alphaRightShift);
-        red = qMin(alpha, (red << redLeftShift) | (red >> redRightShift));
-        green = qMin(alpha, (green << greenLeftShift) | (green >> greenRightShift));
-        blue = qMin(alpha, (blue << blueLeftShift) | (blue >> blueRightShift));
-        buffer[i] = (alpha << 24) | (red << 16) | (green << 8) | blue;
+    if (mustMin) {
+        for (int i = 0; i < count; ++i) {
+            uint alpha = (src[i] >> alphaShift<Format>()) & alphaMask;
+            uint red = (src[i] >> redShift<Format>()) & redMask;
+            uint green = (src[i] >> greenShift<Format>()) & greenMask;
+            uint blue = (src[i] >> blueShift<Format>()) & blueMask;
+
+            alpha = (alpha << alphaLeftShift) | (alpha >> alphaRightShift);
+            red = qMin(alpha, (red << redLeftShift) | (red >> redRightShift));
+            green = qMin(alpha, (green << greenLeftShift) | (green >> greenRightShift));
+            blue = qMin(alpha, (blue << blueLeftShift) | (blue >> blueRightShift));
+            buffer[i] = (alpha << 24) | (red << 16) | (green << 8) | blue;
+        }
+    } else {
+        for (int i = 0; i < count; ++i) {
+            uint alpha = (src[i] >> alphaShift<Format>()) & alphaMask;
+            uint red   = (src[i] >> redShift<Format>())   & redMask;
+            uint green = (src[i] >> greenShift<Format>()) & greenMask;
+            uint blue  = (src[i] >> blueShift<Format>())  & blueMask;
+
+            alpha = ((alpha << alphaLeftShift) | (alpha >> alphaRightShift)) << 24;
+            red   = ((red << redLeftShift) | (red >> redRightShift)) << 16;
+            green = ((green << greenLeftShift) | (green >> greenRightShift)) << 8;
+            blue  = (blue << blueLeftShift)  | (blue >> blueRightShift);
+            buffer[i] = alpha | red | green | blue;
+        }
     }
 
     return buffer;
@@ -270,108 +299,85 @@ static const QRgba64 *QT_FASTCALL convertARGBPMToARGB64PM(QRgba64 *buffer, const
     Q_CONSTEXPR uchar greenRightShift = 2 * greenWidth<Format>() - 8;
     Q_CONSTEXPR uchar blueRightShift = 2 * blueWidth<Format>() - 8;
 
-    for (int i = 0; i < count; ++i) {
-        uint alpha = (src[i] >> alphaShift<Format>()) & alphaMask;
-        uint red = (src[i] >> redShift<Format>()) & redMask;
-        uint green = (src[i] >> greenShift<Format>()) & greenMask;
-        uint blue = (src[i] >> blueShift<Format>()) & blueMask;
+    Q_CONSTEXPR bool mustMin = (alphaWidth<Format>() != redWidth<Format>()) ||
+                               (alphaWidth<Format>() != greenWidth<Format>()) ||
+                               (alphaWidth<Format>() != blueWidth<Format>());
 
-        alpha = (alpha << alphaLeftShift) | (alpha >> alphaRightShift);
-        red = qMin(alpha, (red << redLeftShift) | (red >> redRightShift));
-        green = qMin(alpha, (green << greenLeftShift) | (green >> greenRightShift));
-        blue = qMin(alpha, (blue << blueLeftShift) | (blue >> blueRightShift));
-        buffer[i] = QRgba64::fromRgba(red, green, blue, alpha);
+    if (mustMin) {
+        for (int i = 0; i < count; ++i) {
+            uint alpha = (src[i] >> alphaShift<Format>()) & alphaMask;
+            uint red = (src[i] >> redShift<Format>()) & redMask;
+            uint green = (src[i] >> greenShift<Format>()) & greenMask;
+            uint blue = (src[i] >> blueShift<Format>()) & blueMask;
+
+            alpha = (alpha << alphaLeftShift) | (alpha >> alphaRightShift);
+            red = qMin(alpha, (red << redLeftShift) | (red >> redRightShift));
+            green = qMin(alpha, (green << greenLeftShift) | (green >> greenRightShift));
+            blue = qMin(alpha, (blue << blueLeftShift) | (blue >> blueRightShift));
+            buffer[i] = QRgba64::fromRgba(red, green, blue, alpha);
+        }
+    } else {
+        for (int i = 0; i < count; ++i) {
+            uint alpha = (src[i] >> alphaShift<Format>()) & alphaMask;
+            uint red = (src[i] >> redShift<Format>()) & redMask;
+            uint green = (src[i] >> greenShift<Format>()) & greenMask;
+            uint blue = (src[i] >> blueShift<Format>()) & blueMask;
+
+            alpha = (alpha << alphaLeftShift) | (alpha >> alphaRightShift);
+            red = (red << redLeftShift) | (red >> redRightShift);
+            green = (green << greenLeftShift) | (green >> greenRightShift);
+            blue = (blue << blueLeftShift) | (blue >> blueRightShift);
+            buffer[i] = QRgba64::fromRgba(red, green, blue, alpha);
+        }
     }
 
     return buffer;
 }
 
-template<QImage::Format Format>
+template<QImage::Format Format, bool fromRGB>
 static const uint *QT_FASTCALL convertRGBFromARGB32PM(uint *buffer, const uint *src, int count,
                                                       const QPixelLayout *, const QRgb *)
 {
-    Q_CONSTEXPR uint redMask = ((1 << redWidth<Format>()) - 1);
-    Q_CONSTEXPR uint greenMask = ((1 << greenWidth<Format>()) - 1);
-    Q_CONSTEXPR uint blueMask = ((1 << blueWidth<Format>()) - 1);
+    Q_CONSTEXPR uint rMask = ((1 << redWidth<Format>()) - 1);
+    Q_CONSTEXPR uint gMask = ((1 << greenWidth<Format>()) - 1);
+    Q_CONSTEXPR uint bMask = ((1 << blueWidth<Format>()) - 1);
 
-    Q_CONSTEXPR uchar redRightShift = 24 - redWidth<Format>();
-    Q_CONSTEXPR uchar greenRightShift = 16 - greenWidth<Format>();
-    Q_CONSTEXPR uchar blueRightShift = 8 - blueWidth<Format>();
+    Q_CONSTEXPR uchar rRightShift = 24 - redWidth<Format>();
+    Q_CONSTEXPR uchar gRightShift = 16 - greenWidth<Format>();
+    Q_CONSTEXPR uchar bRightShift =  8 - blueWidth<Format>();
 
     for (int i = 0; i < count; ++i) {
-        const uint color = qUnpremultiply(src[i]);
-        const uint red = ((color >> redRightShift) & redMask) << redShift<Format>();
-        const uint green = ((color >> greenRightShift) & greenMask) << greenShift<Format>();
-        const uint blue = ((color >> blueRightShift) & blueMask) << blueShift<Format>();
-        buffer[i] = red | green | blue;
+        const uint c = fromRGB ? src[i] : qUnpremultiply(src[i]);
+        const uint r = ((c >> rRightShift) & rMask) << redShift<Format>();
+        const uint g = ((c >> gRightShift) & gMask) << greenShift<Format>();
+        const uint b = ((c >> bRightShift) & bMask) << blueShift<Format>();
+        buffer[i] = r | g | b;
     }
     return buffer;
 }
 
-template<QImage::Format Format>
-static const uint *QT_FASTCALL convertRGBFromRGB32(uint *buffer, const uint *src, int count,
-                                                   const QPixelLayout *, const QRgb *)
-{
-    Q_CONSTEXPR uint redMask = ((1 << redWidth<Format>()) - 1);
-    Q_CONSTEXPR uint greenMask = ((1 << greenWidth<Format>()) - 1);
-    Q_CONSTEXPR uint blueMask = ((1 << blueWidth<Format>()) - 1);
-
-    Q_CONSTEXPR uchar redRightShift = 24 - redWidth<Format>();
-    Q_CONSTEXPR uchar greenRightShift = 16 - greenWidth<Format>();
-    Q_CONSTEXPR uchar blueRightShift = 8 - blueWidth<Format>();
-
-    for (int i = 0; i < count; ++i) {
-        const uint red = ((src[i] >> redRightShift) & redMask) << redShift<Format>();
-        const uint green = ((src[i] >> greenRightShift) & greenMask) << greenShift<Format>();
-        const uint blue = ((src[i] >> blueRightShift) & blueMask) << blueShift<Format>();
-        buffer[i] = red | green | blue;
-    }
-    return buffer;
-}
-
-template<QImage::Format Format>
-static const uint *QT_FASTCALL convertARGBPMFromRGB32(uint *buffer, const uint *src, int count,
-                                                    const QPixelLayout *, const QRgb *)
-{
-    Q_CONSTEXPR uint alphaMask = ((1 << alphaWidth<Format>()) - 1);
-    Q_CONSTEXPR uint redMask = ((1 << redWidth<Format>()) - 1);
-    Q_CONSTEXPR uint greenMask = ((1 << greenWidth<Format>()) - 1);
-    Q_CONSTEXPR uint blueMask = ((1 << blueWidth<Format>()) - 1);
-
-    Q_CONSTEXPR uchar redRightShift = 24 - redWidth<Format>();
-    Q_CONSTEXPR uchar greenRightShift = 16 - greenWidth<Format>();
-    Q_CONSTEXPR uchar blueRightShift = 8 - blueWidth<Format>();
-
-    for (int i = 0; i < count; ++i) {
-        Q_CONSTEXPR uint alpha = (0xff & alphaMask) << alphaShift<Format>();
-        const uint red = ((src[i] >> redRightShift) & redMask) << redShift<Format>();
-        const uint green = ((src[i] >> greenRightShift) & greenMask) << greenShift<Format>();
-        const uint blue = ((src[i] >> blueRightShift) & blueMask) << blueShift<Format>();
-        buffer[i] = alpha | red | green | blue;
-    }
-    return buffer;
-}
-
-template<QImage::Format Format>
+template<QImage::Format Format, bool fromRGB>
 static const uint *QT_FASTCALL convertARGBPMFromARGB32PM(uint *buffer, const uint *src, int count,
                                                          const QPixelLayout *, const QRgb *)
 {
-    Q_CONSTEXPR uint alphaMask = ((1 << alphaWidth<Format>()) - 1);
-    Q_CONSTEXPR uint redMask = ((1 << redWidth<Format>()) - 1);
-    Q_CONSTEXPR uint greenMask = ((1 << greenWidth<Format>()) - 1);
-    Q_CONSTEXPR uint blueMask = ((1 << blueWidth<Format>()) - 1);
+    Q_CONSTEXPR uint aMask = ((1 << alphaWidth<Format>()) - 1);
+    Q_CONSTEXPR uint rMask = ((1 << redWidth<Format>()) - 1);
+    Q_CONSTEXPR uint gMask = ((1 << greenWidth<Format>()) - 1);
+    Q_CONSTEXPR uint bMask = ((1 << blueWidth<Format>()) - 1);
 
-    Q_CONSTEXPR uchar alphaRightShift = 32 - alphaWidth<Format>();
-    Q_CONSTEXPR uchar redRightShift = 24 - redWidth<Format>();
-    Q_CONSTEXPR uchar greenRightShift = 16 - greenWidth<Format>();
-    Q_CONSTEXPR uchar blueRightShift = 8 - blueWidth<Format>();
+    Q_CONSTEXPR uchar aRightShift = 32 - alphaWidth<Format>();
+    Q_CONSTEXPR uchar rRightShift = 24 - redWidth<Format>();
+    Q_CONSTEXPR uchar gRightShift = 16 - greenWidth<Format>();
+    Q_CONSTEXPR uchar bRightShift =  8 - blueWidth<Format>();
 
+    Q_CONSTEXPR uint aOpaque = (0xff & aMask) << alphaShift<Format>();
     for (int i = 0; i < count; ++i) {
-        const uint alpha = ((src[i] >> alphaRightShift) & alphaMask) << alphaShift<Format>();
-        const uint red = ((src[i] >> redRightShift) & redMask) << redShift<Format>();
-        const uint green = ((src[i] >> greenRightShift) & greenMask) << greenShift<Format>();
-        const uint blue = ((src[i] >> blueRightShift) & blueMask) << blueShift<Format>();
-        buffer[i] = alpha | red | green | blue;
+        const uint c = src[i];
+        const uint a = fromRGB ? aOpaque : (((c >> aRightShift) & aMask) << alphaShift<Format>());
+        const uint r = ((c >> rRightShift) & rMask) << redShift<Format>();
+        const uint g = ((c >> gRightShift) & gMask) << greenShift<Format>();
+        const uint b = ((c >> bRightShift) & bMask) << blueShift<Format>();
+        buffer[i] = a | r | g | b;
     }
     return buffer;
 }
@@ -387,8 +393,8 @@ template<QImage::Format Format> Q_DECL_CONSTEXPR static inline QPixelLayout pixe
         0, 0,
         false, bitsPerPixel<Format>(),
         convertToRGB32<Format>,
-        convertRGBFromARGB32PM<Format>,
-        convertRGBFromRGB32<Format>,
+        convertRGBFromARGB32PM<Format, false>,
+        convertRGBFromARGB32PM<Format, true>,
         convertToRGB64<Format>
     };
 }
@@ -402,8 +408,8 @@ template<QImage::Format Format> Q_DECL_CONSTEXPR static inline QPixelLayout pixe
         uchar(alphaWidth<Format>()), uchar(alphaShift<Format>()),
         true, bitsPerPixel<Format>(),
         convertARGBPMToARGB32PM<Format>,
-        convertARGBPMFromARGB32PM<Format>,
-        convertARGBPMFromRGB32<Format>,
+        convertARGBPMFromARGB32PM<Format, false>,
+        convertARGBPMFromARGB32PM<Format, true>,
         convertARGBPMToARGB64PM<Format>
     };
 }
@@ -881,56 +887,56 @@ QPixelLayout qPixelLayouts[QImage::NImageFormats] = {
 #else
     { 5, 11, 6,  5, 5,  0, 0,  0, false, QPixelLayout::BPP16,
       convertToRGB32<QImage::Format_RGB16>,
-      convertRGBFromARGB32PM<QImage::Format_RGB16>,
-      convertRGBFromRGB32<QImage::Format_RGB16>,
+      convertRGBFromARGB32PM<QImage::Format_RGB16, false>,
+      convertRGBFromARGB32PM<QImage::Format_RGB16, true>,
       convertToRGB64<QImage::Format_RGB16>,
     },
     { 5, 19, 6, 13, 5,  8, 8,  0,  true, QPixelLayout::BPP24,
       convertARGBPMToARGB32PM<QImage::Format_ARGB8565_Premultiplied>,
-      convertARGBPMFromARGB32PM<QImage::Format_ARGB8565_Premultiplied>,
-      convertARGBPMFromRGB32<QImage::Format_ARGB8565_Premultiplied>,
+      convertARGBPMFromARGB32PM<QImage::Format_ARGB8565_Premultiplied, false>,
+      convertARGBPMFromARGB32PM<QImage::Format_ARGB8565_Premultiplied, true>,
       convertARGBPMToARGB64PM<QImage::Format_ARGB8565_Premultiplied>,
     },
     { 6, 12, 6,  6, 6,  0, 0,  0, false, QPixelLayout::BPP24,
       convertToRGB32<QImage::Format_RGB666>,
-      convertRGBFromARGB32PM<QImage::Format_RGB666>,
-      convertRGBFromRGB32<QImage::Format_RGB666>,
+      convertRGBFromARGB32PM<QImage::Format_RGB666, false>,
+      convertRGBFromARGB32PM<QImage::Format_RGB666, true>,
       convertToRGB64<QImage::Format_RGB666>,
     },
     { 6, 12, 6,  6, 6,  0, 6, 18,  true, QPixelLayout::BPP24,
       convertARGBPMToARGB32PM<QImage::Format_ARGB6666_Premultiplied>,
-      convertARGBPMFromARGB32PM<QImage::Format_ARGB6666_Premultiplied>,
-      convertARGBPMFromRGB32<QImage::Format_ARGB6666_Premultiplied>,
+      convertARGBPMFromARGB32PM<QImage::Format_ARGB6666_Premultiplied, false>,
+      convertARGBPMFromARGB32PM<QImage::Format_ARGB6666_Premultiplied, true>,
       convertARGBPMToARGB64PM<QImage::Format_ARGB6666_Premultiplied>,
     },
     { 5, 10, 5,  5, 5,  0, 0,  0, false, QPixelLayout::BPP16,
       convertToRGB32<QImage::Format_RGB555>,
-      convertRGBFromARGB32PM<QImage::Format_RGB555>,
-      convertRGBFromRGB32<QImage::Format_RGB555>,
+      convertRGBFromARGB32PM<QImage::Format_RGB555, false>,
+      convertRGBFromARGB32PM<QImage::Format_RGB555, true>,
       convertToRGB64<QImage::Format_RGB555>,
     },
     { 5, 18, 5, 13, 5,  8, 8,  0,  true, QPixelLayout::BPP24,
       convertARGBPMToARGB32PM<QImage::Format_ARGB8555_Premultiplied>,
-      convertARGBPMFromARGB32PM<QImage::Format_ARGB8555_Premultiplied>,
-      convertARGBPMFromRGB32<QImage::Format_ARGB8555_Premultiplied>,
+      convertARGBPMFromARGB32PM<QImage::Format_ARGB8555_Premultiplied, false>,
+      convertARGBPMFromARGB32PM<QImage::Format_ARGB8555_Premultiplied, true>,
       convertARGBPMToARGB64PM<QImage::Format_ARGB8555_Premultiplied>,
     },
     { 8, 16, 8,  8, 8,  0, 0,  0, false, QPixelLayout::BPP24,
       convertToRGB32<QImage::Format_RGB888>,
-      convertRGBFromARGB32PM<QImage::Format_RGB888>,
-      convertRGBFromRGB32<QImage::Format_RGB888>,
+      convertRGBFromARGB32PM<QImage::Format_RGB888, false>,
+      convertRGBFromARGB32PM<QImage::Format_RGB888, true>,
       convertToRGB64<QImage::Format_RGB888>,
     },
     { 4,  8, 4,  4, 4,  0, 0,  0, false, QPixelLayout::BPP16,
       convertToRGB32<QImage::Format_RGB444>,
-      convertRGBFromARGB32PM<QImage::Format_RGB444>,
-      convertRGBFromRGB32<QImage::Format_RGB444>,
+      convertRGBFromARGB32PM<QImage::Format_RGB444, false>,
+      convertRGBFromARGB32PM<QImage::Format_RGB444, true>,
       convertToRGB64<QImage::Format_RGB444>,
     },
     { 4,  8, 4,  4, 4,  0, 4, 12,  true, QPixelLayout::BPP16,
       convertARGBPMToARGB32PM<QImage::Format_ARGB4444_Premultiplied>,
-      convertARGBPMFromARGB32PM<QImage::Format_ARGB4444_Premultiplied>,
-      convertARGBPMFromRGB32<QImage::Format_ARGB4444_Premultiplied>,
+      convertARGBPMFromARGB32PM<QImage::Format_ARGB4444_Premultiplied, false>,
+      convertARGBPMFromARGB32PM<QImage::Format_ARGB4444_Premultiplied, true>,
       convertARGBPMToARGB64PM<QImage::Format_ARGB4444_Premultiplied>,
     },
 #endif
@@ -6376,11 +6382,15 @@ static void qInitDrawhelperFunctions()
                                                     int const_alpha);
 
         extern void QT_FASTCALL storePixelsBPP24_ssse3(uchar *dest, const uint *src, int index, int count);
+        extern const uint * QT_FASTCALL qt_fetchUntransformed_888_ssse3(uint *buffer, const Operator *, const QSpanData *data,
+                                                                        int y, int x, int length);
         qBlendFunctions[QImage::Format_RGB32][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_ssse3;
         qBlendFunctions[QImage::Format_ARGB32_Premultiplied][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_argb32_ssse3;
         qBlendFunctions[QImage::Format_RGBX8888][QImage::Format_RGBA8888_Premultiplied] = qt_blend_argb32_on_argb32_ssse3;
         qBlendFunctions[QImage::Format_RGBA8888_Premultiplied][QImage::Format_RGBA8888_Premultiplied] = qt_blend_argb32_on_argb32_ssse3;
         qStorePixels[QPixelLayout::BPP24] = storePixelsBPP24_ssse3;
+        sourceFetch[BlendUntransformed][QImage::Format_RGB888] = qt_fetchUntransformed_888_ssse3;
+        sourceFetch[BlendTiled][QImage::Format_RGB888] = qt_fetchUntransformed_888_ssse3;
     }
 #endif // SSSE3
 
@@ -6443,6 +6453,9 @@ static void qInitDrawhelperFunctions()
 
     qt_fetch_radial_gradient = qt_fetch_radial_gradient_neon;
 
+    sourceFetch[BlendUntransformed][QImage::Format_RGB888] = qt_fetchUntransformed_888_neon;
+    sourceFetch[BlendTiled][QImage::Format_RGB888] = qt_fetchUntransformed_888_neon;
+
 #if defined(ENABLE_PIXMAN_DRAWHELPERS)
     // The RGB16 helpers are using Arm32 assemblythat has not been ported to AArch64
     qBlendFunctions[QImage::Format_RGB16][QImage::Format_ARGB32_Premultiplied] = qt_blend_argb32_on_rgb16_neon;
diff --git a/src/gui/painting/qdrawhelper_mips_dsp.cpp b/src/gui/painting/qdrawhelper_mips_dsp.cpp
index 81ae0f43ba7..b72ca3da3d0 100644
--- a/src/gui/painting/qdrawhelper_mips_dsp.cpp
+++ b/src/gui/painting/qdrawhelper_mips_dsp.cpp
@@ -495,7 +495,7 @@ void QT_FASTCALL comp_func_SourceOut_mips_dsp(uint *dest, const uint *src, int l
 const uint * QT_FASTCALL qt_fetchUntransformed_888_mips_dsp (uint *buffer, const Operator *, const QSpanData *data,
                                              int y, int x, int length)
 {
-    uchar *line = (uchar *)data->texture.scanLine(y) + x;
+    const uchar *line = data->texture.scanLine(y) + x * 3;
     fetchUntransformed_888_asm_mips_dsp(buffer, line, length);
     return buffer;
 }
@@ -503,7 +503,7 @@ const uint * QT_FASTCALL qt_fetchUntransformed_888_mips_dsp (uint *buffer, const
 const uint * QT_FASTCALL qt_fetchUntransformed_444_mips_dsp (uint *buffer, const Operator *, const QSpanData *data,
                                              int y, int x, int length)
 {
-    uchar *line = (uchar *)data->texture.scanLine(y) + x;
+    const uchar *line = data->texture.scanLine(y) + x * 2;
     fetchUntransformed_444_asm_mips_dsp(buffer, line, length);
     return buffer;
 }
@@ -511,7 +511,7 @@ const uint * QT_FASTCALL qt_fetchUntransformed_444_mips_dsp (uint *buffer, const
 const uint * QT_FASTCALL qt_fetchUntransformed_argb8565_premultiplied_mips_dsp (uint *buffer, const Operator *, const QSpanData *data,
                                              int y, int x, int length)
 {
-    uchar *line = (uchar *)data->texture.scanLine(y) + x;
+    const uchar *line = data->texture.scanLine(y) + x * 3;
     fetchUntransformed_argb8565_premultiplied_asm_mips_dsp(buffer, line, length);
     return buffer;
 }
diff --git a/src/gui/painting/qdrawhelper_neon.cpp b/src/gui/painting/qdrawhelper_neon.cpp
index 7dbfa4fa9c2..f5b794ace65 100644
--- a/src/gui/painting/qdrawhelper_neon.cpp
+++ b/src/gui/painting/qdrawhelper_neon.cpp
@@ -1061,6 +1061,16 @@ const uint * QT_FASTCALL qt_fetch_radial_gradient_neon(uint *buffer, const Opera
     return qt_fetch_radial_gradient_template<QRadialFetchSimd<QSimdNeon>,uint>(buffer, op, data, y, x, length);
 }
 
+extern void QT_FASTCALL qt_convert_rgb888_to_rgb32_neon(quint32 *dst, const uchar *src, int len);
+
+const uint * QT_FASTCALL qt_fetchUntransformed_888_neon(uint *buffer, const Operator *, const QSpanData *data,
+                                                       int y, int x, int length)
+{
+    const uchar *line = data->texture.scanLine(y) + x * 3;
+    qt_convert_rgb888_to_rgb32_neon(buffer, line, length);
+    return buffer;
+}
+
 QT_END_NAMESPACE
 
 #endif // __ARM_NEON__
diff --git a/src/gui/painting/qdrawhelper_neon_p.h b/src/gui/painting/qdrawhelper_neon_p.h
index 0134960fa17..3cf949fc322 100644
--- a/src/gui/painting/qdrawhelper_neon_p.h
+++ b/src/gui/painting/qdrawhelper_neon_p.h
@@ -137,6 +137,9 @@ void QT_FASTCALL qt_destStoreRGB16_neon(QRasterBuffer *rasterBuffer,
 void QT_FASTCALL comp_func_solid_SourceOver_neon(uint *destPixels, int length, uint color, uint const_alpha);
 void QT_FASTCALL comp_func_Plus_neon(uint *dst, const uint *src, int length, uint const_alpha);
 
+const uint * QT_FASTCALL qt_fetchUntransformed_888_neon(uint *buffer, const Operator *, const QSpanData *data,
+                                                       int y, int x, int length);
+
 #endif // __ARM_NEON__
 
 QT_END_NAMESPACE
diff --git a/src/gui/painting/qdrawhelper_ssse3.cpp b/src/gui/painting/qdrawhelper_ssse3.cpp
index e0d1bac6b11..7cd3e9ca1b5 100644
--- a/src/gui/painting/qdrawhelper_ssse3.cpp
+++ b/src/gui/painting/qdrawhelper_ssse3.cpp
@@ -233,6 +233,16 @@ void QT_FASTCALL storePixelsBPP24_ssse3(uchar *dest, const uint *src, int index,
     store_uint24_ssse3(dest + index * 3, src, count);
 }
 
+extern void QT_FASTCALL qt_convert_rgb888_to_rgb32_ssse3(quint32 *dst, const uchar *src, int len);
+
+const uint * QT_FASTCALL qt_fetchUntransformed_888_ssse3(uint *buffer, const Operator *, const QSpanData *data,
+                                                         int y, int x, int length)
+{
+    const uchar *line = data->texture.scanLine(y) + x * 3;
+    qt_convert_rgb888_to_rgb32_ssse3(buffer, line, length);
+    return buffer;
+}
+
 QT_END_NAMESPACE
 
 #endif // QT_COMPILER_SUPPORTS_SSSE3
diff --git a/src/gui/painting/qpagelayout.cpp b/src/gui/painting/qpagelayout.cpp
index 317e6d241a8..f3f7f5f9563 100644
--- a/src/gui/painting/qpagelayout.cpp
+++ b/src/gui/painting/qpagelayout.cpp
@@ -949,40 +949,37 @@ QRect QPageLayout::paintRectPixels(int resolution) const
 QDebug operator<<(QDebug dbg, const QPageLayout &layout)
 {
     QDebugStateSaver saver(dbg);
+    dbg.nospace();
+    dbg.noquote();
+    dbg << "QPageLayout(";
     if (layout.isValid()) {
-        QString output = QStringLiteral("QPageLayout(%1, %2, l:%3 r:%4 t:%5 b:%6 %7)");
-        QString units;
+        const QMarginsF margins = layout.margins();
+        dbg << '"' << layout.pageSize().name() << "\", "
+            << (layout.orientation() == QPageLayout::Portrait ? "Portrait" : "Landscape")
+            << ", l:" << margins.left() << " r:" << margins.right() << " t:"
+            << margins.top() << " b:" << margins.bottom() << ' ';
         switch (layout.units()) {
         case QPageLayout::Millimeter:
-            units = QStringLiteral("mm");
+            dbg << "mm";
             break;
         case QPageLayout::Point:
-            units = QStringLiteral("pt");
+            dbg << "pt";
             break;
         case QPageLayout::Inch:
-            units = QStringLiteral("in");
+            dbg << "in";
             break;
         case QPageLayout::Pica:
-            units = QStringLiteral("pc");
+            dbg << "pc";
             break;
         case QPageLayout::Didot:
-            units = QStringLiteral("DD");
+            dbg << "DD";
             break;
         case QPageLayout::Cicero:
-            units = QStringLiteral("CC");
+            dbg << "CC";
             break;
         }
-        output = output.arg(layout.pageSize().name())
-                       .arg(layout.orientation() == QPageLayout::Portrait ? QStringLiteral("Portrait") : QStringLiteral("Landscape"))
-                       .arg(layout.margins().left())
-                       .arg(layout.margins().right())
-                       .arg(layout.margins().top())
-                       .arg(layout.margins().bottom())
-                       .arg(units);
-        dbg.nospace() << output;
-    } else {
-        dbg.nospace() << "QPageLayout()";
     }
+    dbg << ')';
     return dbg;
 }
 #endif
diff --git a/src/gui/painting/qpagesize.cpp b/src/gui/painting/qpagesize.cpp
index c5a2e7288bb..f53285d9cb3 100644
--- a/src/gui/painting/qpagesize.cpp
+++ b/src/gui/painting/qpagesize.cpp
@@ -1861,17 +1861,17 @@ QSize QPageSize::sizePixels(PageSizeId pageSizeId, int resolution)
 QDebug operator<<(QDebug dbg, const QPageSize &pageSize)
 {
     QDebugStateSaver saver(dbg);
+    dbg.nospace();
+    dbg.noquote();
+    dbg << "QPageSize(";
     if (pageSize.isValid()) {
-        QString output = QStringLiteral("QPageSize(\"%1\", \"%2\", %3x%4pt, %5)");
-        output = output.arg(pageSize.name())
-                       .arg(pageSize.key())
-                       .arg(pageSize.sizePoints().width())
-                       .arg(pageSize.sizePoints().height())
-                       .arg(pageSize.id());
-        dbg.nospace() << output;
+        dbg << '"' << pageSize.name() << "\", key=\"" << pageSize.key()
+            << "\", " << pageSize.sizePoints().width() << 'x'
+            << pageSize.sizePoints().height() << "pt, id=" << pageSize.id();
     } else {
         dbg.nospace() << "QPageSize()";
     }
+    dbg << ')';
     return dbg;
 }
 #endif
diff --git a/src/gui/painting/qpaintengine_raster.cpp b/src/gui/painting/qpaintengine_raster.cpp
index 51a46e4ee9a..00dc4ccb812 100644
--- a/src/gui/painting/qpaintengine_raster.cpp
+++ b/src/gui/painting/qpaintengine_raster.cpp
@@ -1163,7 +1163,7 @@ void QRasterPaintEngine::clip(const QVectorPath &path, Qt::ClipOperation op)
         if (s->matrix.type() <= QTransform::TxScale
             && path.isRect()) {
 #ifdef QT_DEBUG_DRAW
-            qDebug() << " --- optimizing vector clip to rect clip...";
+            qDebug(" --- optimizing vector clip to rect clip...");
 #endif
             const qreal *points = path.points();
             QRectF r(points[0], points[1], points[4]-points[0], points[5]-points[1]);
diff --git a/src/gui/painting/qpainterpath.h b/src/gui/painting/qpainterpath.h
index 8513e6d407d..882918fc877 100644
--- a/src/gui/painting/qpainterpath.h
+++ b/src/gui/painting/qpainterpath.h
@@ -230,6 +230,7 @@ private:
 #endif
 };
 
+Q_DECLARE_SHARED_NOT_MOVABLE_UNTIL_QT6(QPainterPath)
 Q_DECLARE_TYPEINFO(QPainterPath::Element, Q_PRIMITIVE_TYPE);
 
 #ifndef QT_NO_DATASTREAM
diff --git a/src/gui/painting/qpathclipper.cpp b/src/gui/painting/qpathclipper.cpp
index cdc9838dbec..48ae3cfc808 100644
--- a/src/gui/painting/qpathclipper.cpp
+++ b/src/gui/painting/qpathclipper.cpp
@@ -258,8 +258,6 @@ class SegmentTree
 public:
     SegmentTree(QPathSegments &segments);
 
-    QRectF boundingRect() const;
-
     void produceIntersections(int segment);
 
 private:
@@ -310,12 +308,6 @@ SegmentTree::SegmentTree(QPathSegments &segments)
     m_tree[0] = root;
 }
 
-QRectF SegmentTree::boundingRect() const
-{
-    return QRectF(QPointF(m_bounds.x1, m_bounds.y1),
-                  QPointF(m_bounds.x2, m_bounds.y2));
-}
-
 static inline qreal coordinate(const QPointF &pos, int axis)
 {
     return axis == 0 ? pos.x() : pos.y();
@@ -1761,6 +1753,7 @@ struct QCrossingEdge
         return x < edge.x;
     }
 };
+Q_DECLARE_TYPEINFO(QCrossingEdge, Q_PRIMITIVE_TYPE);
 
 static bool bool_op(bool a, bool b, QPathClipper::Operation op)
 {
diff --git a/src/gui/painting/qpdf.cpp b/src/gui/painting/qpdf.cpp
index 5ac5ad06a8f..86f176bc99c 100644
--- a/src/gui/painting/qpdf.cpp
+++ b/src/gui/painting/qpdf.cpp
@@ -1950,7 +1950,7 @@ int QPdfEnginePrivate::writeImage(const QByteArray &data, int width, int height,
         xprintf("/Interpolate true\n");
     int len = 0;
     if (dct) {
-        //qDebug() << "DCT";
+        //qDebug("DCT");
         xprintf("/Filter /DCTDecode\n>>\nstream\n");
         write(data);
         len = data.length();
@@ -1975,6 +1975,7 @@ struct QGradientBound {
     int function;
     bool reverse;
 };
+Q_DECLARE_TYPEINFO(QGradientBound, Q_PRIMITIVE_TYPE);
 
 int QPdfEnginePrivate::createShadingFunction(const QGradient *gradient, int from, int to, bool reflect, bool alpha)
 {
@@ -2213,7 +2214,7 @@ int QPdfEnginePrivate::generateGradientShader(const QGradient *gradient, const Q
         return generateRadialGradientShader(static_cast<const QRadialGradient *>(gradient), matrix, alpha);
     case QGradient::ConicalGradient:
     default:
-        qWarning() << "Implement me!";
+        qWarning("Implement me!");
     }
     return 0;
 }
diff --git a/src/gui/painting/qpolygon.h b/src/gui/painting/qpolygon.h
index 7b77ee50144..23bdd1933f3 100644
--- a/src/gui/painting/qpolygon.h
+++ b/src/gui/painting/qpolygon.h
@@ -98,6 +98,7 @@ public:
     QPolygon intersected(const QPolygon &r) const Q_REQUIRED_RESULT;
     QPolygon subtracted(const QPolygon &r) const Q_REQUIRED_RESULT;
 };
+Q_DECLARE_SHARED_NOT_MOVABLE_UNTIL_QT6(QPolygon)
 
 inline QPolygon::QPolygon(int asize) : QVector<QPoint>(asize) {}
 
@@ -174,6 +175,7 @@ public:
     QPolygonF intersected(const QPolygonF &r) const Q_REQUIRED_RESULT;
     QPolygonF subtracted(const QPolygonF &r) const Q_REQUIRED_RESULT;
 };
+Q_DECLARE_SHARED_NOT_MOVABLE_UNTIL_QT6(QPolygonF)
 
 inline QPolygonF::QPolygonF(int asize) : QVector<QPointF>(asize) {}
 
diff --git a/src/gui/painting/qtransform.cpp b/src/gui/painting/qtransform.cpp
index a0596d1a079..6058811176f 100644
--- a/src/gui/painting/qtransform.cpp
+++ b/src/gui/painting/qtransform.cpp
@@ -53,6 +53,14 @@
 
 QT_BEGIN_NAMESPACE
 
+#ifndef QT_NO_DEBUG
+Q_NEVER_INLINE
+static void nanWarning(const char *func)
+{
+    qWarning("QTransform::%s with NaN called", func);
+}
+#endif // QT_NO_DEBUG
+
 #define Q_NEAR_CLIP (sizeof(qreal) == sizeof(double) ? 0.000001 : 0.0001)
 
 #ifdef MAP
@@ -418,7 +426,7 @@ QTransform &QTransform::translate(qreal dx, qreal dy)
         return *this;
 #ifndef QT_NO_DEBUG
     if (qIsNaN(dx) | qIsNaN(dy)) {
-        qWarning() << "QTransform::translate with NaN called";
+        nanWarning("translate");
         return *this;
     }
 #endif
@@ -461,7 +469,7 @@ QTransform QTransform::fromTranslate(qreal dx, qreal dy)
 {
 #ifndef QT_NO_DEBUG
     if (qIsNaN(dx) | qIsNaN(dy)) {
-        qWarning() << "QTransform::fromTranslate with NaN called";
+        nanWarning("fromTranslate");
         return QTransform();
 }
 #endif
@@ -486,7 +494,7 @@ QTransform & QTransform::scale(qreal sx, qreal sy)
         return *this;
 #ifndef QT_NO_DEBUG
     if (qIsNaN(sx) | qIsNaN(sy)) {
-        qWarning() << "QTransform::scale with NaN called";
+        nanWarning("scale");
         return *this;
     }
 #endif
@@ -527,7 +535,7 @@ QTransform QTransform::fromScale(qreal sx, qreal sy)
 {
 #ifndef QT_NO_DEBUG
     if (qIsNaN(sx) | qIsNaN(sy)) {
-        qWarning() << "QTransform::fromScale with NaN called";
+        nanWarning("fromScale");
         return QTransform();
 }
 #endif
@@ -552,7 +560,7 @@ QTransform & QTransform::shear(qreal sh, qreal sv)
         return *this;
 #ifndef QT_NO_DEBUG
     if (qIsNaN(sh) | qIsNaN(sv)) {
-        qWarning() << "QTransform::shear with NaN called";
+        nanWarning("shear");
         return *this;
     }
 #endif
@@ -613,7 +621,7 @@ QTransform & QTransform::rotate(qreal a, Qt::Axis axis)
         return *this;
 #ifndef QT_NO_DEBUG
     if (qIsNaN(a)) {
-        qWarning() << "QTransform::rotate with NaN called";
+        nanWarning("rotate");
         return *this;
     }
 #endif
@@ -704,7 +712,7 @@ QTransform & QTransform::rotateRadians(qreal a, Qt::Axis axis)
 {
 #ifndef QT_NO_DEBUG
     if (qIsNaN(a)) {
-        qWarning() << "QTransform::rotateRadians with NaN called";
+        nanWarning("rotateRadians");
         return *this;
     }
 #endif
diff --git a/src/gui/text/qabstracttextdocumentlayout.h b/src/gui/text/qabstracttextdocumentlayout.h
index d3631887423..e2fad12ad3f 100644
--- a/src/gui/text/qabstracttextdocumentlayout.h
+++ b/src/gui/text/qabstracttextdocumentlayout.h
@@ -131,6 +131,8 @@ private:
     Q_PRIVATE_SLOT(d_func(), int _q_dynamicPageCountSlot())
     Q_PRIVATE_SLOT(d_func(), QSizeF _q_dynamicDocumentSizeSlot())
 };
+Q_DECLARE_TYPEINFO(QAbstractTextDocumentLayout::Selection,    Q_RELOCATABLE_TYPE);
+Q_DECLARE_TYPEINFO(QAbstractTextDocumentLayout::PaintContext, Q_RELOCATABLE_TYPE);
 
 class Q_GUI_EXPORT QTextObjectInterface
 {
diff --git a/src/gui/text/qfont.cpp b/src/gui/text/qfont.cpp
index 898b2680708..7e182500878 100644
--- a/src/gui/text/qfont.cpp
+++ b/src/gui/text/qfont.cpp
@@ -137,7 +137,7 @@ extern bool qt_is_gui_used;
 
 Q_GUI_EXPORT int qt_defaultDpiX()
 {
-    if (qApp->testAttribute(Qt::AA_Use96Dpi))
+    if (QCoreApplication::instance()->testAttribute(Qt::AA_Use96Dpi))
         return 96;
 
     if (!qt_is_gui_used)
@@ -152,7 +152,7 @@ Q_GUI_EXPORT int qt_defaultDpiX()
 
 Q_GUI_EXPORT int qt_defaultDpiY()
 {
-    if (qApp->testAttribute(Qt::AA_Use96Dpi))
+    if (QCoreApplication::instance()->testAttribute(Qt::AA_Use96Dpi))
         return 96;
 
     if (!qt_is_gui_used)
diff --git a/src/gui/text/qfontdatabase.cpp b/src/gui/text/qfontdatabase.cpp
index 32cf1b0e830..629a098fb7f 100644
--- a/src/gui/text/qfontdatabase.cpp
+++ b/src/gui/text/qfontdatabase.cpp
@@ -499,6 +499,7 @@ public:
 
     void invalidate();
 };
+Q_DECLARE_TYPEINFO(QFontDatabasePrivate::ApplicationFont, Q_MOVABLE_TYPE);
 
 void QFontDatabasePrivate::invalidate()
 {
diff --git a/src/gui/text/qfontengine.cpp b/src/gui/text/qfontengine.cpp
index 7c0492bb1a8..96f7e06a471 100644
--- a/src/gui/text/qfontengine.cpp
+++ b/src/gui/text/qfontengine.cpp
@@ -246,8 +246,8 @@ Q_AUTOTEST_EXPORT QList<QFontEngine *> QFontEngine_stopCollectingEngines()
 
 QFontEngine::QFontEngine(Type type)
     : m_type(type), ref(0),
-      font_(0), font_destroy_func(0),
-      face_(0), face_destroy_func(0),
+      font_(),
+      face_(),
       m_minLeftBearing(kBearingNotInitialized),
       m_minRightBearing(kBearingNotInitialized)
 {
@@ -269,17 +269,6 @@ QFontEngine::QFontEngine(Type type)
 
 QFontEngine::~QFontEngine()
 {
-    m_glyphCaches.clear();
-
-    if (font_ && font_destroy_func) {
-        font_destroy_func(font_);
-        font_ = 0;
-    }
-    if (face_ && face_destroy_func) {
-        face_destroy_func(face_);
-        face_ = 0;
-    }
-
 #ifdef QT_BUILD_INTERNAL
     if (enginesCollector)
         enginesCollector->removeOne(this);
@@ -334,10 +323,9 @@ void *QFontEngine::harfbuzzFont() const
         hbFont->x_scale = (((qint64)hbFont->x_ppem << 6) * 0x10000L + (emSquare >> 1)) / emSquare;
         hbFont->y_scale = (((qint64)hbFont->y_ppem << 6) * 0x10000L + (emSquare >> 1)) / emSquare;
 
-        font_ = (void *)hbFont;
-        font_destroy_func = free;
+        font_ = Holder(hbFont, free);
     }
-    return font_;
+    return font_.get();
 }
 
 void *QFontEngine::harfbuzzFace() const
@@ -357,10 +345,9 @@ void *QFontEngine::harfbuzzFace() const
         Q_CHECK_PTR(hbFace);
         hbFace->isSymbolFont = symbol;
 
-        face_ = (void *)hbFace;
-        face_destroy_func = hb_freeFace;
+        face_ = Holder(hbFace, hb_freeFace);
     }
-    return face_;
+    return face_.get();
 }
 
 bool QFontEngine::supportsScript(QChar::Script script) const
diff --git a/src/gui/text/qfontengine_ft.cpp b/src/gui/text/qfontengine_ft.cpp
index 779333351f9..9d62a03f4c9 100644
--- a/src/gui/text/qfontengine_ft.cpp
+++ b/src/gui/text/qfontengine_ft.cpp
@@ -246,9 +246,6 @@ QFreetypeFace *QFreetypeFace::getFace(const QFontEngine::FaceId &face_id,
         }
         newFreetype->face = face;
 
-        newFreetype->hbFace = 0;
-        newFreetype->hbFace_destroy_func = 0;
-
         newFreetype->ref.store(1);
         newFreetype->xsize = 0;
         newFreetype->ysize = 0;
@@ -300,10 +297,7 @@ QFreetypeFace *QFreetypeFace::getFace(const QFontEngine::FaceId &face_id,
 
 void QFreetypeFace::cleanup()
 {
-    if (hbFace && hbFace_destroy_func) {
-        hbFace_destroy_func(hbFace);
-        hbFace = 0;
-    }
+    hbFace.reset();
     FT_Done_Face(face);
     face = 0;
 }
@@ -686,6 +680,8 @@ bool QFontEngineFT::init(FaceId faceId, bool antialias, GlyphFormat format,
     return init(faceId, antialias, format, QFreetypeFace::getFace(faceId, fontData));
 }
 
+static void dont_delete(void*) {}
+
 bool QFontEngineFT::init(FaceId faceId, bool antialias, GlyphFormat format,
                          QFreetypeFace *freetypeFace)
 {
@@ -776,13 +772,13 @@ bool QFontEngineFT::init(FaceId faceId, bool antialias, GlyphFormat format,
     if (!freetype->hbFace) {
         faceData.user_data = face;
         faceData.get_font_table = ft_getSfntTable;
-        freetype->hbFace = harfbuzzFace();
-        freetype->hbFace_destroy_func = face_destroy_func;
+        (void)harfbuzzFace(); // populates face_
+        freetype->hbFace = std::move(face_);
     } else {
         Q_ASSERT(!face_);
-        face_ = freetype->hbFace;
     }
-    face_destroy_func = 0; // we share the HB face in QFreeTypeFace, so do not let ~QFontEngine() destroy it
+    // we share the HB face in QFreeTypeFace, so do not let ~QFontEngine() destroy it
+    face_ = Holder(freetype->hbFace.get(), dont_delete);
 
     unlockFace();
 
@@ -1079,8 +1075,8 @@ QFontEngineFT::Glyph *QFontEngineFT::loadGlyph(QGlyphSet *set, uint glyph,
     if (glyph_buffer_size < pitch * info.height) {
         glyph_buffer_size = pitch * info.height;
         glyph_buffer.reset(new uchar[glyph_buffer_size]);
+        memset(glyph_buffer.data(), 0, glyph_buffer_size);
     }
-    memset(glyph_buffer.data(), 0, glyph_buffer_size);
 
     if (slot->format == FT_GLYPH_FORMAT_OUTLINE) {
         FT_Bitmap bitmap;
diff --git a/src/gui/text/qfontengine_ft_p.h b/src/gui/text/qfontengine_ft_p.h
index 1886fc67bad..f9b37ff0392 100644
--- a/src/gui/text/qfontengine_ft_p.h
+++ b/src/gui/text/qfontengine_ft_p.h
@@ -121,8 +121,7 @@ private:
     QMutex _lock;
     QByteArray fontData;
 
-    void *hbFace;
-    qt_destroy_func_t hbFace_destroy_func;
+    QFontEngine::Holder hbFace;
 };
 
 // If this is exported this breaks compilation of the windows
diff --git a/src/gui/text/qfontengine_p.h b/src/gui/text/qfontengine_p.h
index f97f91da50e..1ef3a360d4c 100644
--- a/src/gui/text/qfontengine_p.h
+++ b/src/gui/text/qfontengine_p.h
@@ -275,10 +275,45 @@ public:
     QAtomicInt ref;
     QFontDef fontDef;
 
-    mutable void *font_;
-    mutable qt_destroy_func_t font_destroy_func;
-    mutable void *face_;
-    mutable qt_destroy_func_t face_destroy_func;
+    class Holder { // replace by std::unique_ptr once available
+        void *ptr;
+        qt_destroy_func_t destroy_func;
+    public:
+        Holder() : ptr(nullptr), destroy_func(nullptr) {}
+        explicit Holder(void *p, qt_destroy_func_t d) : ptr(p), destroy_func(d) {}
+        ~Holder() { if (ptr && destroy_func) destroy_func(ptr); }
+        Holder(Holder &&other) Q_DECL_NOTHROW
+            : ptr(other.ptr),
+              destroy_func(other.destroy_func)
+        {
+            other.ptr = nullptr;
+            other.destroy_func = nullptr;
+        }
+        Holder &operator=(Holder &&other) Q_DECL_NOTHROW
+        { swap(other); return *this; }
+
+        void swap(Holder &other) Q_DECL_NOTHROW
+        {
+            qSwap(ptr, other.ptr);
+            qSwap(destroy_func, other.destroy_func);
+        }
+
+        void *get() const Q_DECL_NOTHROW { return ptr; }
+        void *release() Q_DECL_NOTHROW {
+            void *result = ptr;
+            ptr = nullptr;
+            destroy_func = nullptr;
+            return result;
+        }
+        void reset() Q_DECL_NOTHROW { Holder().swap(*this); }
+        qt_destroy_func_t get_deleter() const Q_DECL_NOTHROW { return destroy_func; }
+
+        bool operator!() const Q_DECL_NOTHROW { return !ptr; }
+    };
+
+    mutable Holder font_; // \ NOTE: Declared before m_glyphCaches, so font_, face_
+    mutable Holder face_; // / are destroyed _after_ m_glyphCaches is destroyed.
+
     struct FaceData {
         void *user_data;
         qt_get_font_table_func_t get_font_table;
@@ -334,6 +369,7 @@ private:
     mutable qreal m_minRightBearing;
 
 };
+Q_DECLARE_TYPEINFO(QFontEngine::KernPair, Q_PRIMITIVE_TYPE);
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(QFontEngine::ShaperFlags)
 
diff --git a/src/gui/text/qfontengine_qpf2.cpp b/src/gui/text/qfontengine_qpf2.cpp
index 4b5d241e60e..c3a911fc55a 100644
--- a/src/gui/text/qfontengine_qpf2.cpp
+++ b/src/gui/text/qfontengine_qpf2.cpp
@@ -246,7 +246,7 @@ QFontEngineQPF2::QFontEngineQPF2(const QFontDef &def, const QByteArray &data)
 
     if (!verifyHeader(fontData, dataSize)) {
 #if defined(DEBUG_FONTENGINE)
-        qDebug() << "verifyHeader failed!";
+        qDebug("verifyHeader failed!");
 #endif
         return;
     }
diff --git a/src/gui/text/qfontsubset.cpp b/src/gui/text/qfontsubset.cpp
index a9387e5aa09..f591b4333c2 100644
--- a/src/gui/text/qfontsubset.cpp
+++ b/src/gui/text/qfontsubset.cpp
@@ -798,7 +798,7 @@ static void convertPath(const QPainterPath &path, QVector<TTF_POINT> *points, QV
                     base -= 3;
                 } else {
                     // need to split
-//                     qDebug() << "  -> splitting";
+//                     qDebug("  -> splitting");
                     qint16 a, b, c, d;
                     base[6].x = base[3].x;
                     c = base[1].x;
@@ -859,7 +859,7 @@ static void getBounds(const QVector<TTF_POINT> &points, qint16 *xmin, qint16 *xm
 static int convertToRelative(QVector<TTF_POINT> *points)
 {
     // convert points to relative and setup flags
-//     qDebug() << "relative points:";
+//     qDebug("relative points:");
     qint16 prev_x = 0;
     qint16 prev_y = 0;
     int point_array_size = 0;
@@ -980,7 +980,7 @@ static QTtfGlyph generateGlyph(int index, const QPainterPath &path, qreal advanc
 //     qDebug() << "number of contours=" << endPoints.size();
 //     for (int i = 0; i < points.size(); ++i)
 //         qDebug() << "  point[" << i << "] = " << QPoint(points.at(i).x, points.at(i).y) << " flags=" << points.at(i).flags;
-//     qDebug() << "endPoints:";
+//     qDebug("endPoints:");
 //     for (int i = 0; i < endPoints.size(); ++i)
 //         qDebug() << endPoints.at(i);
 
diff --git a/src/gui/text/qharfbuzzng.cpp b/src/gui/text/qharfbuzzng.cpp
index e33b4614017..55ef9f0d15c 100644
--- a/src/gui/text/qharfbuzzng.cpp
+++ b/src/gui/text/qharfbuzzng.cpp
@@ -678,14 +678,10 @@ hb_face_t *hb_qt_face_get_for_engine(QFontEngine *fe)
 {
     Q_ASSERT(fe && fe->type() != QFontEngine::Multi);
 
-    if (Q_UNLIKELY(!fe->face_)) {
-        fe->face_ = _hb_qt_face_create(fe);
-        if (Q_UNLIKELY(!fe->face_))
-            return NULL;
-        fe->face_destroy_func = _hb_qt_face_release;
-    }
+    if (Q_UNLIKELY(!fe->face_))
+        fe->face_ = QFontEngine::Holder(_hb_qt_face_create(fe), _hb_qt_face_release);
 
-    return static_cast<hb_face_t *>(fe->face_);
+    return static_cast<hb_face_t *>(fe->face_.get());
 }
 
 
@@ -728,14 +724,10 @@ hb_font_t *hb_qt_font_get_for_engine(QFontEngine *fe)
 {
     Q_ASSERT(fe && fe->type() != QFontEngine::Multi);
 
-    if (Q_UNLIKELY(!fe->font_)) {
-        fe->font_ = _hb_qt_font_create(fe);
-        if (Q_UNLIKELY(!fe->font_))
-            return NULL;
-        fe->font_destroy_func = _hb_qt_font_release;
-    }
+    if (Q_UNLIKELY(!fe->font_))
+        fe->font_ = QFontEngine::Holder(_hb_qt_font_create(fe), _hb_qt_font_release);
 
-    return static_cast<hb_font_t *>(fe->font_);
+    return static_cast<hb_font_t *>(fe->font_.get());
 }
 
 QT_END_NAMESPACE
diff --git a/src/gui/text/qplatformfontdatabase.cpp b/src/gui/text/qplatformfontdatabase.cpp
index 017e2f254d4..0d7cb204ff2 100644
--- a/src/gui/text/qplatformfontdatabase.cpp
+++ b/src/gui/text/qplatformfontdatabase.cpp
@@ -100,7 +100,7 @@ void QPlatformFontDatabase::registerQPF2Font(const QByteArray &dataArray, void *
             registerFont(fontName,QString(),QString(),fontWeight,fontStyle,stretch,true,false,pixelSize,false,writingSystems,handle);
         }
     } else {
-        qDebug() << "header verification of QPF2 font failed. maybe it is corrupt?";
+        qDebug("header verification of QPF2 font failed. maybe it is corrupt?");
     }
 }
 
diff --git a/src/gui/text/qrawfont.cpp b/src/gui/text/qrawfont.cpp
index ca6093227d0..6065e17d9b7 100644
--- a/src/gui/text/qrawfont.cpp
+++ b/src/gui/text/qrawfont.cpp
@@ -614,8 +614,7 @@ QByteArray QRawFont::fontTable(const char *tagName) const
     if (!d->isValid())
         return QByteArray();
 
-    const quint32 *tagId = reinterpret_cast<const quint32 *>(tagName);
-    return d->fontEngine->getSfntTable(qToBigEndian(*tagId));
+    return d->fontEngine->getSfntTable(MAKE_TAG(tagName[0], tagName[1], tagName[2], tagName[3]));
 }
 
 /*!
diff --git a/src/gui/text/qstatictext_p.h b/src/gui/text/qstatictext_p.h
index d27d5a8725d..7fdf46c101a 100644
--- a/src/gui/text/qstatictext_p.h
+++ b/src/gui/text/qstatictext_p.h
@@ -119,6 +119,7 @@ private: // private to avoid abuse
                                                                   // ================
                                                                   // 43 bytes per item
 };
+Q_DECLARE_TYPEINFO(QStaticTextItem, Q_MOVABLE_TYPE);
 
 class QStaticText;
 class Q_AUTOTEST_EXPORT QStaticTextPrivate
diff --git a/src/gui/text/qtextdocumentfragment_p.h b/src/gui/text/qtextdocumentfragment_p.h
index 4cc4f0429f5..56dff011498 100644
--- a/src/gui/text/qtextdocumentfragment_p.h
+++ b/src/gui/text/qtextdocumentfragment_p.h
@@ -148,6 +148,7 @@ private:
         int listNode;
         QPointer<QTextList> list;
     };
+    friend class QTypeInfo<List>;
     QVector<List> lists;
     int indent;
 
@@ -187,6 +188,7 @@ private:
         int row;
         int column;
     };
+    friend class QTypeInfo<TableCellIterator>;
 
     friend struct Table;
     struct Table
@@ -200,6 +202,7 @@ private:
         TableCellIterator currentCell;
         int lastIndent;
     };
+    friend class QTypeInfo<Table>;
     QVector<Table> tables;
 
     struct RowColSpanInfo
@@ -207,6 +210,7 @@ private:
         int row, col;
         int rowSpan, colSpan;
     };
+    friend class QTypeInfo<RowColSpanInfo>;
 
     enum WhiteSpace
     {
@@ -227,6 +231,10 @@ private:
     int currentNodeIdx;
     const QTextHtmlParserNode *currentNode;
 };
+Q_DECLARE_TYPEINFO(QTextHtmlImporter::List, Q_MOVABLE_TYPE);
+Q_DECLARE_TYPEINFO(QTextHtmlImporter::TableCellIterator, Q_PRIMITIVE_TYPE);
+Q_DECLARE_TYPEINFO(QTextHtmlImporter::Table, Q_MOVABLE_TYPE);
+Q_DECLARE_TYPEINFO(QTextHtmlImporter::RowColSpanInfo, Q_PRIMITIVE_TYPE);
 
 QT_END_NAMESPACE
 #endif // QT_NO_TEXTHTMLPARSER
diff --git a/src/gui/text/qtextdocumentlayout.cpp b/src/gui/text/qtextdocumentlayout.cpp
index 4d5dc820d57..a8b57d6dfdd 100644
--- a/src/gui/text/qtextdocumentlayout.cpp
+++ b/src/gui/text/qtextdocumentlayout.cpp
@@ -1598,7 +1598,7 @@ QTextLayoutStruct QTextDocumentLayoutPrivate::layoutCell(QTextTable *t, const QT
     // floats in other cells we must clear the list here.
     data(t)->floats.clear();
 
-//    qDebug() << "layoutCell done";
+//    qDebug("layoutCell done");
 
     return layoutStruct;
 }
@@ -2030,7 +2030,7 @@ void QTextDocumentLayoutPrivate::positionFloat(QTextFrame *frame, QTextLine *cur
 //         qDebug() << "have line: right=" << right << "left=" << left << "textWidth=" << currentLine->width();
         if (right - left < QFixed::fromReal(currentLine->naturalTextWidth()) + fd->size.width) {
             layoutStruct->pendingFloats.append(frame);
-//             qDebug() << "    adding to pending list";
+//             qDebug("    adding to pending list");
             return;
         }
     }
@@ -2543,7 +2543,7 @@ void QTextDocumentLayoutPrivate::layoutFlow(QTextFrame::Iterator it, QTextLayout
             contentHasAlignment = true;
 
         if (it.atEnd()) {
-            //qDebug() << "layout done!";
+            //qDebug("layout done!");
             currentLazyLayoutPosition = -1;
             QCheckPoint cp;
             cp.y = layoutStruct->y;
diff --git a/src/gui/text/qtextdocumentwriter.cpp b/src/gui/text/qtextdocumentwriter.cpp
index d672b1187a5..a7c58ac2a61 100644
--- a/src/gui/text/qtextdocumentwriter.cpp
+++ b/src/gui/text/qtextdocumentwriter.cpp
@@ -271,7 +271,7 @@ bool QTextDocumentWriter::write(const QTextDocument *document)
 #ifndef QT_NO_TEXTHTMLPARSER
     if (format == "html" || format == "htm") {
         if (!d->device->isWritable() && ! d->device->open(QIODevice::WriteOnly)) {
-            qWarning() << "QTextDocumentWriter::write: the device can not be opened for writing";
+            qWarning("QTextDocumentWriter::write: the device can not be opened for writing");
             return false;
         }
         QTextStream ts(d->device);
@@ -285,7 +285,7 @@ bool QTextDocumentWriter::write(const QTextDocument *document)
 #endif
     if (format == "txt" || format == "plaintext") {
         if (!d->device->isWritable() && ! d->device->open(QIODevice::WriteOnly)) {
-            qWarning() << "QTextDocumentWriter::write: the device can not be opened for writing";
+            qWarning("QTextDocumentWriter::write: the device can not be opened for writing");
             return false;
         }
         QTextStream ts(d->device);
diff --git a/src/gui/text/qtextengine.cpp b/src/gui/text/qtextengine.cpp
index 7708157697c..8e037970802 100644
--- a/src/gui/text/qtextengine.cpp
+++ b/src/gui/text/qtextengine.cpp
@@ -816,7 +816,7 @@ void QTextEngine::bidiReorder(int numItems, const quint8 *levels, int *visualOrd
     }
 
 #if (BIDI_DEBUG >= 1)
-//     qDebug() << "visual order is:";
+//     qDebug("visual order is:");
 //     for (i = 0; i < numItems; i++)
 //         qDebug() << visualOrder[i];
 #endif
@@ -2753,8 +2753,7 @@ QString QTextEngine::elidedText(Qt::TextElideMode mode, const QFixed &width, int
     QFixed ellipsisWidth;
     QString ellipsisText;
     {
-        QFontEngine *fe = fnt.d->engineForScript(QChar::Script_Common);
-        QFontEngine *engine = fe->type() == QFontEngine::Multi ? static_cast<QFontEngineMulti *>(fe)->engine(0) : fe;
+        QFontEngine *engine = fnt.d->engineForScript(QChar::Script_Common);
 
         QChar ellipsisChar(0x2026);
 
diff --git a/src/gui/text/qtextformat.cpp b/src/gui/text/qtextformat.cpp
index 58049399efa..49ec9ca768b 100644
--- a/src/gui/text/qtextformat.cpp
+++ b/src/gui/text/qtextformat.cpp
@@ -263,6 +263,7 @@ private:
     friend QDataStream &operator<<(QDataStream &, const QTextFormat &);
     friend QDataStream &operator>>(QDataStream &, QTextFormat &);
 };
+Q_DECLARE_TYPEINFO(QTextFormatPrivate::Property, Q_MOVABLE_TYPE);
 
 static inline uint hash(const QColor &color)
 {
diff --git a/src/gui/text/qtextformat.h b/src/gui/text/qtextformat.h
index 9dd83ab678e..bc627521ff1 100644
--- a/src/gui/text/qtextformat.h
+++ b/src/gui/text/qtextformat.h
@@ -116,6 +116,7 @@ private:
     friend Q_GUI_EXPORT QDataStream &operator<<(QDataStream &, const QTextLength &);
     friend Q_GUI_EXPORT QDataStream &operator>>(QDataStream &, QTextLength &);
 };
+Q_DECLARE_TYPEINFO(QTextLength, QT_VERSION >= QT_VERSION_CHECK(6,0,0) ? Q_PRIMITIVE_TYPE : Q_RELOCATABLE_TYPE);
 
 inline QTextLength::QTextLength(Type atype, qreal avalue)
     : lengthType(atype), fixedValueOrPercentage(avalue) {}
diff --git a/src/gui/text/qtexthtmlparser_p.h b/src/gui/text/qtexthtmlparser_p.h
index a8a849ca7fe..8e5a90be0b9 100644
--- a/src/gui/text/qtexthtmlparser_p.h
+++ b/src/gui/text/qtexthtmlparser_p.h
@@ -328,12 +328,14 @@ protected:
         QString url;
         QCss::StyleSheet sheet;
     };
+    friend class QTypeInfo<ExternalStyleSheet>;
     QVector<ExternalStyleSheet> externalStyleSheets;
     QVector<QCss::StyleSheet> inlineStyleSheets;
 #endif
 
     const QTextDocument *resourceProvider;
 };
+Q_DECLARE_TYPEINFO(QTextHtmlParser::ExternalStyleSheet, Q_MOVABLE_TYPE);
 
 QT_END_NAMESPACE
 
diff --git a/src/gui/text/qtextlayout.cpp b/src/gui/text/qtextlayout.cpp
index e2939785b27..83f2a9bc25f 100644
--- a/src/gui/text/qtextlayout.cpp
+++ b/src/gui/text/qtextlayout.cpp
@@ -2980,7 +2980,7 @@ int QTextLine::xToCursor(qreal _x, CursorPosition cpos) const
         }
     }
     // right of last item
-//     qDebug() << "right of last";
+//     qDebug("right of last");
     int item = visualOrder[nItems-1]+firstItem;
     QScriptItem &si = eng->layoutData->items[item];
     if (!si.num_glyphs)
diff --git a/src/gui/text/qtextlayout.h b/src/gui/text/qtextlayout.h
index d9afb1ed4ba..1cbb5ac8d8e 100644
--- a/src/gui/text/qtextlayout.h
+++ b/src/gui/text/qtextlayout.h
@@ -203,6 +203,7 @@ private:
                                QPainter *painter);
     QTextEngine *d;
 };
+Q_DECLARE_TYPEINFO(QTextLayout::FormatRange, Q_RELOCATABLE_TYPE);
 
 
 class Q_GUI_EXPORT QTextLine
diff --git a/src/gui/text/qtextodfwriter.cpp b/src/gui/text/qtextodfwriter.cpp
index 4baa94edd5e..bd2a9d5183c 100644
--- a/src/gui/text/qtextodfwriter.cpp
+++ b/src/gui/text/qtextodfwriter.cpp
@@ -769,7 +769,7 @@ bool QTextOdfWriter::writeAll()
         m_strategy = new QXmlStreamStrategy(m_device);
 
     if (!m_device->isWritable() && ! m_device->open(QIODevice::WriteOnly)) {
-        qWarning() << "QTextOdfWriter::writeAll: the device can not be opened for writing";
+        qWarning("QTextOdfWriter::writeAll: the device can not be opened for writing");
         return false;
     }
     QXmlStreamWriter writer(m_strategy->contentStream);
diff --git a/src/gui/text/qzip.cpp b/src/gui/text/qzip.cpp
index 4f43f73d411..5178f5a9a8e 100644
--- a/src/gui/text/qzip.cpp
+++ b/src/gui/text/qzip.cpp
@@ -574,7 +574,7 @@ void QZipReaderPrivate::scanFiles()
     uchar tmp[4];
     device->read((char *)tmp, 4);
     if (readUInt(tmp) != 0x04034b50) {
-        qWarning() << "QZip: not a zip file!";
+        qWarning("QZip: not a zip file!");
         return;
     }
 
@@ -586,7 +586,7 @@ void QZipReaderPrivate::scanFiles()
     while (start_of_directory == -1) {
         const int pos = device->size() - int(sizeof(EndOfDirectory)) - i;
         if (pos < 0 || i > 65535) {
-            qWarning() << "QZip: EndOfDirectory not found";
+            qWarning("QZip: EndOfDirectory not found");
             return;
         }
 
@@ -603,7 +603,7 @@ void QZipReaderPrivate::scanFiles()
     ZDEBUG("start_of_directory at %d, num_dir_entries=%d", start_of_directory, num_dir_entries);
     int comment_length = readUShort(eod.comment_length);
     if (comment_length != i)
-        qWarning() << "QZip: failed to parse zip file.";
+        qWarning("QZip: failed to parse zip file.");
     comment = device->read(qMin(comment_length, i));
 
 
@@ -612,30 +612,30 @@ void QZipReaderPrivate::scanFiles()
         FileHeader header;
         int read = device->read((char *) &header.h, sizeof(CentralFileHeader));
         if (read < (int)sizeof(CentralFileHeader)) {
-            qWarning() << "QZip: Failed to read complete header, index may be incomplete";
+            qWarning("QZip: Failed to read complete header, index may be incomplete");
             break;
         }
         if (readUInt(header.h.signature) != 0x02014b50) {
-            qWarning() << "QZip: invalid header signature, index may be incomplete";
+            qWarning("QZip: invalid header signature, index may be incomplete");
             break;
         }
 
         int l = readUShort(header.h.file_name_length);
         header.file_name = device->read(l);
         if (header.file_name.length() != l) {
-            qWarning() << "QZip: Failed to read filename from zip index, index may be incomplete";
+            qWarning("QZip: Failed to read filename from zip index, index may be incomplete");
             break;
         }
         l = readUShort(header.h.extra_field_length);
         header.extra_field = device->read(l);
         if (header.extra_field.length() != l) {
-            qWarning() << "QZip: Failed to read extra field in zip file, skipping file, index may be incomplete";
+            qWarning("QZip: Failed to read extra field in zip file, skipping file, index may be incomplete");
             break;
         }
         l = readUShort(header.h.file_comment_length);
         header.file_comment = device->read(l);
         if (header.file_comment.length() != l) {
-            qWarning() << "QZip: Failed to read read file comment, index may be incomplete";
+            qWarning("QZip: Failed to read read file comment, index may be incomplete");
             break;
         }
 
@@ -824,14 +824,15 @@ QZipReader::QZipReader(const QString &archive, QIODevice::OpenMode mode)
     QScopedPointer<QFile> f(new QFile(archive));
     f->open(mode);
     QZipReader::Status status;
-    if (f->error() == QFile::NoError)
+    const QFileDevice::FileError error = f->error();
+    if (error == QFile::NoError)
         status = NoError;
     else {
-        if (f->error() == QFile::ReadError)
+        if (error == QFile::ReadError)
             status = FileReadError;
-        else if (f->error() == QFile::OpenError)
+        else if (error == QFile::OpenError)
             status = FileOpenError;
-        else if (f->error() == QFile::PermissionsError)
+        else if (error == QFile::PermissionsError)
             status = FilePermissionsError;
         else
             status = FileError;
diff --git a/src/gui/util/qdesktopservices.cpp b/src/gui/util/qdesktopservices.cpp
index 1cfea8634a4..085c073bb12 100644
--- a/src/gui/util/qdesktopservices.cpp
+++ b/src/gui/util/qdesktopservices.cpp
@@ -328,17 +328,17 @@ QString QDesktopServices::storageLocationImpl(QStandardPaths::StandardLocation t
         // * Unix data location is under the "data/" subdirectory
         const QString compatAppName = qt_applicationName_noFallback();
         const QString baseDir = QStandardPaths::writableLocation(QStandardPaths::GenericDataLocation);
+        const QString organizationName = QCoreApplication::organizationName();
 #if defined(Q_OS_WIN) || defined(Q_OS_MAC)
         QString result = baseDir;
-        if (!QCoreApplication::organizationName().isEmpty())
-            result += QLatin1Char('/') + QCoreApplication::organizationName();
+        if (!organizationName.isEmpty())
+            result += QLatin1Char('/') + organizationName;
         if (!compatAppName.isEmpty())
             result += QLatin1Char('/') + compatAppName;
         return result;
 #elif defined(Q_OS_UNIX)
         return baseDir + QLatin1String("/data/")
-            + QCoreApplication::organizationName() + QLatin1Char('/')
-            + compatAppName;
+            + organizationName + QLatin1Char('/') + compatAppName;
 #endif
     }
     return QStandardPaths::writableLocation(type);
diff --git a/src/gui/util/qgridlayoutengine.cpp b/src/gui/util/qgridlayoutengine.cpp
index ae8bde89104..20bc7166aba 100644
--- a/src/gui/util/qgridlayoutengine.cpp
+++ b/src/gui/util/qgridlayoutengine.cpp
@@ -416,8 +416,23 @@ void QGridLayoutRowData::calculateGeometries(int start, int end, qreal targetSiz
 #endif
     }
     if (snapToPixelGrid) {
-        for (int i = 0; i < n; ++i)
-            positions[i] = qround(positions[i]);
+        for (int i = 0; i < n; ++i) {
+            const qreal oldpos = positions[i];
+            positions[i] = qround(oldpos);
+            const qreal delta = positions[i] - oldpos;
+            sizes[i] -= delta;
+            if (i > 0)
+                sizes[i - 1] += delta;
+        }
+
+        sizes[n - 1] = targetSize - positions[n - 1];
+        // This loop serves two purposes:
+        // 1. round off the small epsilons produced by the above loop.
+        // 2. avoid that the above loop didn't make the cell width smaller than its minimum constraint.
+        for (int i = 0; i < n; ++i) {
+            const QGridLayoutBox &box = boxes.at(start + i);
+            sizes[i] = qMax(box.q_minimumSize, qround(sizes[i]));
+        }
     }
 
     if (descents) {
@@ -569,7 +584,7 @@ QLayoutPolicy::ControlTypes QGridLayoutItem::controlTypes(LayoutSide /*side*/) c
     return QLayoutPolicy::DefaultType;
 }
 
-QGridLayoutBox QGridLayoutItem::box(Qt::Orientation orientation, qreal constraint) const
+QGridLayoutBox QGridLayoutItem::box(Qt::Orientation orientation, bool snapToPixelGrid, qreal constraint) const
 {
     QGridLayoutBox result;
     QLayoutPolicy::Policy policy = sizePolicy(orientation);
@@ -584,6 +599,8 @@ QGridLayoutBox QGridLayoutItem::box(Qt::Orientation orientation, qreal constrain
         } else {
             result.q_minimumSize = result.q_preferredSize;
         }
+        if (snapToPixelGrid)
+            result.q_minimumSize = qCeil(result.q_minimumSize);
 
         if (policy & (QLayoutPolicy::GrowFlag | QLayoutPolicy::ExpandFlag)) {
             result.q_maximumSize = sizeHint(Qt::MaximumSize, constraintSize).width();
@@ -600,6 +617,8 @@ QGridLayoutBox QGridLayoutItem::box(Qt::Orientation orientation, qreal constrain
         } else {
             result.q_minimumSize = result.q_preferredSize;
         }
+        if (snapToPixelGrid)
+            result.q_minimumSize = qCeil(result.q_minimumSize);
 
         if (policy & (QLayoutPolicy::GrowFlag | QLayoutPolicy::ExpandFlag)) {
             result.q_maximumSize = sizeHint(Qt::MaximumSize, constraintSize).height();
@@ -623,7 +642,7 @@ QGridLayoutBox QGridLayoutItem::box(Qt::Orientation orientation, qreal constrain
 }
 
 QRectF QGridLayoutItem::geometryWithin(qreal x, qreal y, qreal width, qreal height,
-                                       qreal rowDescent, Qt::Alignment align) const
+                                       qreal rowDescent, Qt::Alignment align, bool snapToPixelGrid) const
 {
     const qreal cellWidth = width;
     const qreal cellHeight = height;
@@ -661,7 +680,7 @@ QRectF QGridLayoutItem::geometryWithin(qreal x, qreal y, qreal width, qreal heig
         break;
     case Qt::AlignBaseline: {
         width = qMin(effectiveMaxSize(QSizeF(-1,-1)).width(), width);
-        QGridLayoutBox vBox = box(Qt::Vertical);
+        QGridLayoutBox vBox = box(Qt::Vertical, snapToPixelGrid);
         const qreal descent = vBox.q_minimumDescent;
         const qreal ascent = vBox.q_minimumSize - descent;
         y += (cellHeight - rowDescent - ascent);
@@ -1027,7 +1046,7 @@ void QGridLayoutEngine::setGeometries(const QRectF &contentsGeometry, const QAbs
 
         const Qt::Alignment align = effectiveAlignment(item);
         QRectF geom = item->geometryWithin(contentsGeometry.x() + x, contentsGeometry.y() + y,
-                                               width, height, q_descents[item->lastRow()], align);
+                                               width, height, q_descents[item->lastRow()], align, m_snapToPixelGrid);
         if (m_snapToPixelGrid) {
             // x and y should already be rounded, but the call to geometryWithin() above might
             // result in a geom with x,y at half-pixels (due to centering within the cell)
@@ -1407,9 +1426,9 @@ void QGridLayoutEngine::fillRowData(QGridLayoutRowData *rowData,
                         qreal length = colSizes[item->lastColumn(orientation)];
                         if (item->columnSpan(orientation) != 1)
                             length += colPositions[item->lastColumn(orientation)] - colPositions[item->firstColumn(orientation)];
-                        box->combine(item->box(orientation, length));
+                        box->combine(item->box(orientation, m_snapToPixelGrid, length));
                     } else {
-                        box->combine(item->box(orientation));
+                        box->combine(item->box(orientation, m_snapToPixelGrid));
                     }
 
                     if (effectiveRowSpan == 1) {
@@ -1477,8 +1496,8 @@ void QGridLayoutEngine::fillRowData(QGridLayoutRowData *rowData,
                         if (orientation == Qt::Horizontal) {
                             qreal width1 = rowData->boxes.at(prevRow).q_minimumSize;
                             qreal width2 = rowData->boxes.at(row).q_minimumSize;
-                            QRectF rect1 = item1->geometryWithin(0.0, 0.0, width1, FLT_MAX, -1.0, effectiveAlignment(item1));
-                            QRectF rect2 = item2->geometryWithin(0.0, 0.0, width2, FLT_MAX, -1.0, effectiveAlignment(item2));
+                            QRectF rect1 = item1->geometryWithin(0.0, 0.0, width1, FLT_MAX, -1.0, effectiveAlignment(item1), m_snapToPixelGrid);
+                            QRectF rect2 = item2->geometryWithin(0.0, 0.0, width2, FLT_MAX, -1.0, effectiveAlignment(item2), m_snapToPixelGrid);
                             spacing -= (width1 - (rect1.x() + rect1.width())) + rect2.x();
                         } else {
                             const QGridLayoutBox &box1 = rowData->boxes.at(prevRow);
@@ -1490,9 +1509,9 @@ void QGridLayoutEngine::fillRowData(QGridLayoutRowData *rowData,
                             qreal rowDescent2 = fixedDescent(box2.q_minimumDescent,
                                                              box2.q_minimumAscent, height2);
                             QRectF rect1 = item1->geometryWithin(0.0, 0.0, FLT_MAX, height1,
-                                                                 rowDescent1, effectiveAlignment(item1));
+                                                                 rowDescent1, effectiveAlignment(item1), m_snapToPixelGrid);
                             QRectF rect2 = item2->geometryWithin(0.0, 0.0, FLT_MAX, height2,
-                                                                 rowDescent2, effectiveAlignment(item2));
+                                                                 rowDescent2, effectiveAlignment(item2), m_snapToPixelGrid);
                             spacing -= (height1 - (rect1.y() + rect1.height())) + rect2.y();
                         }
                         rowSpacing = qMax(spacing, rowSpacing);
diff --git a/src/gui/util/qgridlayoutengine_p.h b/src/gui/util/qgridlayoutengine_p.h
index 1075a6f8f27..b3ed2d287b4 100644
--- a/src/gui/util/qgridlayoutengine_p.h
+++ b/src/gui/util/qgridlayoutengine_p.h
@@ -314,8 +314,8 @@ public:
 
     virtual QLayoutPolicy::ControlTypes controlTypes(LayoutSide side) const;
 
-    QRectF geometryWithin(qreal x, qreal y, qreal width, qreal height, qreal rowDescent, Qt::Alignment align) const;
-    QGridLayoutBox box(Qt::Orientation orientation, qreal constraint = -1.0) const;
+    QRectF geometryWithin(qreal x, qreal y, qreal width, qreal height, qreal rowDescent, Qt::Alignment align, bool snapToPixelGrid) const;
+    QGridLayoutBox box(Qt::Orientation orientation, bool snapToPixelGrid, qreal constraint = -1.0) const;
 
 
     void transpose();
diff --git a/src/network/access/qhttpnetworkconnection.cpp b/src/network/access/qhttpnetworkconnection.cpp
index 15a886c21d1..69687b5ab80 100644
--- a/src/network/access/qhttpnetworkconnection.cpp
+++ b/src/network/access/qhttpnetworkconnection.cpp
@@ -234,7 +234,7 @@ bool QHttpNetworkConnectionPrivate::shouldEmitChannelError(QAbstractSocket *sock
                 emitError = false;
             }
             if (networkLayerState == QHttpNetworkConnectionPrivate::Unknown)
-                qWarning() << "We got a connection error when networkLayerState is Unknown";
+                qWarning("We got a connection error when networkLayerState is Unknown");
         }
     }
     return emitError;
@@ -1180,10 +1180,9 @@ void QHttpNetworkConnectionPrivate::_q_hostLookupFinished(const QHostInfo &info)
         }
 #ifndef QT_NO_SSL
         else if (connectionType == QHttpNetworkConnection::ConnectionTypeSPDY) {
-            QList<HttpMessagePair> spdyPairs = channels[0].spdyRequestsToSend.values();
-            for (int a = 0; a < spdyPairs.count(); ++a) {
+            for (const HttpMessagePair &spdyPair : qAsConst(channels[0].spdyRequestsToSend)) {
                 // emit error for all replies
-                QHttpNetworkReply *currentReply = spdyPairs.at(a).second;
+                QHttpNetworkReply *currentReply = spdyPair.second;
                 Q_ASSERT(currentReply);
                 emitReplyError(channels[0].socket, currentReply, QNetworkReply::HostNotFoundError);
             }
@@ -1191,7 +1190,7 @@ void QHttpNetworkConnectionPrivate::_q_hostLookupFinished(const QHostInfo &info)
 #endif // QT_NO_SSL
         else {
             // Should not happen
-            qWarning() << "QHttpNetworkConnectionPrivate::_q_hostLookupFinished could not dequeu request";
+            qWarning("QHttpNetworkConnectionPrivate::_q_hostLookupFinished could not de-queue request");
             networkLayerState = QHttpNetworkConnectionPrivate::Unknown;
         }
     }
diff --git a/src/network/access/qhttpnetworkconnectionchannel.cpp b/src/network/access/qhttpnetworkconnectionchannel.cpp
index dc1f12ff6bb..56716cbe013 100644
--- a/src/network/access/qhttpnetworkconnectionchannel.cpp
+++ b/src/network/access/qhttpnetworkconnectionchannel.cpp
@@ -418,7 +418,7 @@ void QHttpNetworkConnectionChannel::allDone()
     Q_ASSERT(reply);
 
     if (!reply) {
-        qWarning() << "QHttpNetworkConnectionChannel::allDone() called without reply. Please report at http://bugreports.qt.io/";
+        qWarning("QHttpNetworkConnectionChannel::allDone() called without reply. Please report at http://bugreports.qt.io/");
         return;
     }
 
diff --git a/src/network/access/qhttpnetworkreply.cpp b/src/network/access/qhttpnetworkreply.cpp
index f4510c34983..3601c36bc2c 100644
--- a/src/network/access/qhttpnetworkreply.cpp
+++ b/src/network/access/qhttpnetworkreply.cpp
@@ -558,9 +558,8 @@ qint64 QHttpNetworkReplyPrivate::readHeader(QAbstractSocket *socket)
             if (c == '\n') {
                 // check for possible header endings. As per HTTP rfc,
                 // the header endings will be marked by CRLFCRLF. But
-                // we will allow CRLFCRLF, CRLFLF, LFLF
-                if (fragment.endsWith("\r\n\r\n")
-                    || fragment.endsWith("\r\n\n")
+                // we will allow CRLFCRLF, CRLFLF, LFCRLF, LFLF
+                if (fragment.endsWith("\n\r\n")
                     || fragment.endsWith("\n\n"))
                     allHeaders = true;
 
diff --git a/src/network/access/qhttpnetworkreply_p.h b/src/network/access/qhttpnetworkreply_p.h
index 653097fed33..da39633dd19 100644
--- a/src/network/access/qhttpnetworkreply_p.h
+++ b/src/network/access/qhttpnetworkreply_p.h
@@ -181,7 +181,7 @@ private:
 };
 
 
-class QHttpNetworkReplyPrivate : public QObjectPrivate, public QHttpNetworkHeaderPrivate
+class Q_AUTOTEST_EXPORT QHttpNetworkReplyPrivate : public QObjectPrivate, public QHttpNetworkHeaderPrivate
 {
 public:
     QHttpNetworkReplyPrivate(const QUrl &newUrl = QUrl());
diff --git a/src/network/access/qhttpprotocolhandler.cpp b/src/network/access/qhttpprotocolhandler.cpp
index 6adafae8688..b486b75449a 100644
--- a/src/network/access/qhttpprotocolhandler.cpp
+++ b/src/network/access/qhttpprotocolhandler.cpp
@@ -260,7 +260,7 @@ bool QHttpProtocolHandler::sendRequest()
 
     if (!m_reply) {
         // heh, how should that happen!
-        qWarning() << "QAbstractProtocolHandler::sendRequest() called without QHttpNetworkReply";
+        qWarning("QAbstractProtocolHandler::sendRequest() called without QHttpNetworkReply");
         return false;
     }
 
diff --git a/src/network/access/qhttpthreaddelegate.cpp b/src/network/access/qhttpthreaddelegate.cpp
index 43eb85f1afe..3adf71ccfb1 100644
--- a/src/network/access/qhttpthreaddelegate.cpp
+++ b/src/network/access/qhttpthreaddelegate.cpp
@@ -128,7 +128,7 @@ static QByteArray makeCacheKey(QUrl &url, QNetworkProxy *proxy)
 {
     QString result;
     QUrl copy = url;
-    QString scheme = copy.scheme().toLower();
+    QString scheme = copy.scheme();
     bool isEncrypted = scheme == QLatin1String("https");
     copy.setPort(copy.port(isEncrypted ? 443 : 80));
     if (scheme == QLatin1String("preconnect-http")) {
diff --git a/src/network/access/qnetworkaccessbackend.cpp b/src/network/access/qnetworkaccessbackend.cpp
index c2914117dba..9c223dd32f8 100644
--- a/src/network/access/qnetworkaccessbackend.cpp
+++ b/src/network/access/qnetworkaccessbackend.cpp
@@ -385,15 +385,11 @@ bool QNetworkAccessBackend::start()
             // Session not ready, but can skip for loopback connections
 
             // This is not ideal.
-            const QString host = reply->url.host();
-
-            if (host == QLatin1String("localhost") ||
-                QHostAddress(host).isLoopback() ||
-                reply->url.isLocalFile()) {
-                // Don't need an open session for localhost access.
-            } else {
-                // need to wait for session to be opened
-                return false;
+            // Don't need an open session for localhost access.
+            if (!reply->url.isLocalFile()) {
+                const QString host = reply->url.host();
+                if (host != QLatin1String("localhost") && !QHostAddress(host).isLoopback())
+                    return false; // need to wait for session to be opened
             }
         }
     }
diff --git a/src/network/access/qnetworkaccessmanager.cpp b/src/network/access/qnetworkaccessmanager.cpp
index c481eba9e65..ed586c1de52 100644
--- a/src/network/access/qnetworkaccessmanager.cpp
+++ b/src/network/access/qnetworkaccessmanager.cpp
@@ -1125,42 +1125,40 @@ QNetworkReply *QNetworkAccessManager::createRequest(QNetworkAccessManager::Opera
     Q_D(QNetworkAccessManager);
 
     bool isLocalFile = req.url().isLocalFile();
-    QString scheme = req.url().scheme().toLower();
+    QString scheme = req.url().scheme();
 
     // fast path for GET on file:// URLs
     // The QNetworkAccessFileBackend will right now only be used for PUT
-    if ((op == QNetworkAccessManager::GetOperation || op == QNetworkAccessManager::HeadOperation)
-        && (isLocalFile || scheme == QLatin1String("qrc")
-#if defined(Q_OS_ANDROID)
+    if (op == QNetworkAccessManager::GetOperation
+     || op == QNetworkAccessManager::HeadOperation) {
+        if (isLocalFile
+#ifdef Q_OS_ANDROID
             || scheme == QLatin1String("assets")
 #endif
-            )) {
-        return new QNetworkReplyFileImpl(this, req, op);
-    }
+            || scheme == QLatin1String("qrc")) {
+            return new QNetworkReplyFileImpl(this, req, op);
+        }
 
-    if ((op == QNetworkAccessManager::GetOperation || op == QNetworkAccessManager::HeadOperation)
-            && scheme == QLatin1String("data")) {
-        return new QNetworkReplyDataImpl(this, req, op);
-    }
+        if (scheme == QLatin1String("data"))
+            return new QNetworkReplyDataImpl(this, req, op);
 
-    // A request with QNetworkRequest::AlwaysCache does not need any bearer management
-    QNetworkRequest::CacheLoadControl mode =
-        static_cast<QNetworkRequest::CacheLoadControl>(
-            req.attribute(QNetworkRequest::CacheLoadControlAttribute,
+        // A request with QNetworkRequest::AlwaysCache does not need any bearer management
+        QNetworkRequest::CacheLoadControl mode =
+            static_cast<QNetworkRequest::CacheLoadControl>(
+                req.attribute(QNetworkRequest::CacheLoadControlAttribute,
                               QNetworkRequest::PreferNetwork).toInt());
-    if (mode == QNetworkRequest::AlwaysCache
-        && (op == QNetworkAccessManager::GetOperation
-        || op == QNetworkAccessManager::HeadOperation)) {
-        // FIXME Implement a QNetworkReplyCacheImpl instead, see QTBUG-15106
-        QNetworkReplyImpl *reply = new QNetworkReplyImpl(this);
-        QNetworkReplyImplPrivate *priv = reply->d_func();
-        priv->manager = this;
-        priv->backend = new QNetworkAccessCacheBackend();
-        priv->backend->manager = this->d_func();
-        priv->backend->setParent(reply);
-        priv->backend->reply = priv;
-        priv->setup(op, req, outgoingData);
-        return reply;
+        if (mode == QNetworkRequest::AlwaysCache) {
+            // FIXME Implement a QNetworkReplyCacheImpl instead, see QTBUG-15106
+            QNetworkReplyImpl *reply = new QNetworkReplyImpl(this);
+            QNetworkReplyImplPrivate *priv = reply->d_func();
+            priv->manager = this;
+            priv->backend = new QNetworkAccessCacheBackend();
+            priv->backend->manager = this->d_func();
+            priv->backend->setParent(reply);
+            priv->backend->reply = priv;
+            priv->setup(op, req, outgoingData);
+            return reply;
+        }
     }
 
 #ifndef QT_NO_BEARERMANAGEMENT
diff --git a/src/network/access/qnetworkcookiejar.cpp b/src/network/access/qnetworkcookiejar.cpp
index 1ae49aeee97..398895e92f8 100644
--- a/src/network/access/qnetworkcookiejar.cpp
+++ b/src/network/access/qnetworkcookiejar.cpp
@@ -224,7 +224,7 @@ QList<QNetworkCookie> QNetworkCookieJar::cookiesForUrl(const QUrl &url) const
     Q_D(const QNetworkCookieJar);
     const QDateTime now = QDateTime::currentDateTimeUtc();
     QList<QNetworkCookie> result;
-    bool isEncrypted = url.scheme().toLower() == QLatin1String("https");
+    bool isEncrypted = url.scheme() == QLatin1String("https");
 
     // scan our cookies for something that matches
     QList<QNetworkCookie>::ConstIterator it = d->allCookies.constBegin(),
@@ -331,7 +331,8 @@ bool QNetworkCookieJar::deleteCookie(const QNetworkCookie &cookie)
 bool QNetworkCookieJar::validateCookie(const QNetworkCookie &cookie, const QUrl &url) const
 {
     QString domain = cookie.domain();
-    if (!(isParentDomain(domain, url.host()) || isParentDomain(url.host(), domain)))
+    const QString host = url.host();
+    if (!isParentDomain(domain, host) && !isParentDomain(host, domain))
         return false; // not accepted
 
     // the check for effective TLDs makes the "embedded dot" rule from RFC 2109 section 4.3.2
diff --git a/src/network/access/qnetworkdiskcache.cpp b/src/network/access/qnetworkdiskcache.cpp
index 5d38ebcd868..99e67cb463a 100644
--- a/src/network/access/qnetworkdiskcache.cpp
+++ b/src/network/access/qnetworkdiskcache.cpp
@@ -160,7 +160,7 @@ void QNetworkDiskCache::setCacheDirectory(const QString &cacheDir)
 qint64 QNetworkDiskCache::cacheSize() const
 {
 #if defined(QNETWORKDISKCACHE_DEBUG)
-    qDebug() << "QNetworkDiskCache::cacheSize()";
+    qDebug("QNetworkDiskCache::cacheSize()");
 #endif
     Q_D(const QNetworkDiskCache);
     if (d->cacheDirectory.isEmpty())
@@ -185,7 +185,7 @@ QIODevice *QNetworkDiskCache::prepare(const QNetworkCacheMetaData &metaData)
         return 0;
 
     if (d->cacheDirectory.isEmpty()) {
-        qWarning() << "QNetworkDiskCache::prepare() The cache directory is not set";
+        qWarning("QNetworkDiskCache::prepare() The cache directory is not set");
         return 0;
     }
 
@@ -212,7 +212,7 @@ QIODevice *QNetworkDiskCache::prepare(const QNetworkCacheMetaData &metaData)
             cacheItem->file = 0;
         }
         if (!cacheItem->file || !cacheItem->file->open()) {
-            qWarning() << "QNetworkDiskCache::prepare() unable to open temporary file";
+            qWarning("QNetworkDiskCache::prepare() unable to open temporary file");
             cacheItem.reset();
             return 0;
         }
@@ -448,7 +448,7 @@ void QNetworkDiskCache::updateMetaData(const QNetworkCacheMetaData &metaData)
     QIODevice *oldDevice = data(url);
     if (!oldDevice) {
 #if defined(QNETWORKDISKCACHE_DEBUG)
-        qDebug() << "QNetworkDiskCache::updateMetaData(), no device!";
+        qDebug("QNetworkDiskCache::updateMetaData(), no device!");
 #endif
         return;
     }
@@ -521,7 +521,7 @@ qint64 QNetworkDiskCache::expire()
         return d->currentCacheSize;
 
     if (cacheDirectory().isEmpty()) {
-        qWarning() << "QNetworkDiskCache::expire() The cache directory is not set";
+        qWarning("QNetworkDiskCache::expire() The cache directory is not set");
         return 0;
     }
 
@@ -584,7 +584,7 @@ qint64 QNetworkDiskCache::expire()
 void QNetworkDiskCache::clear()
 {
 #if defined(QNETWORKDISKCACHE_DEBUG)
-    qDebug() << "QNetworkDiskCache::clear()";
+    qDebug("QNetworkDiskCache::clear()");
 #endif
     Q_D(QNetworkDiskCache);
     qint64 size = d->maximumCacheSize;
diff --git a/src/network/access/qnetworkreplyfileimpl.cpp b/src/network/access/qnetworkreplyfileimpl.cpp
index 8d63fa3fd66..ef319ebf0da 100644
--- a/src/network/access/qnetworkreplyfileimpl.cpp
+++ b/src/network/access/qnetworkreplyfileimpl.cpp
@@ -101,11 +101,12 @@ QNetworkReplyFileImpl::QNetworkReplyFileImpl(QNetworkAccessManager *manager, con
 
     QString fileName = url.toLocalFile();
     if (fileName.isEmpty()) {
-        if (url.scheme() == QLatin1String("qrc")) {
+        const QString scheme = url.scheme();
+        if (scheme == QLatin1String("qrc")) {
             fileName = QLatin1Char(':') + url.path();
         } else {
 #if defined(Q_OS_ANDROID)
-            if (url.scheme() == QLatin1String("assets"))
+            if (scheme == QLatin1String("assets"))
                 fileName = QLatin1String("assets:") + url.path();
             else
 #endif
diff --git a/src/network/access/qnetworkreplyhttpimpl.cpp b/src/network/access/qnetworkreplyhttpimpl.cpp
index 9e39315268a..6b77ab303ff 100644
--- a/src/network/access/qnetworkreplyhttpimpl.cpp
+++ b/src/network/access/qnetworkreplyhttpimpl.cpp
@@ -627,7 +627,7 @@ void QNetworkReplyHttpImplPrivate::postRequest(const QNetworkRequest &newHttpReq
     httpRequest.setUrl(url);
     httpRequest.setRedirectCount(newHttpRequest.maximumRedirectsAllowed());
 
-    QString scheme = url.scheme().toLower();
+    QString scheme = url.scheme();
     bool ssl = (scheme == QLatin1String("https")
                 || scheme == QLatin1String("preconnect-https"));
     q->setAttribute(QNetworkRequest::ConnectionEncryptedAttribute, ssl);
@@ -675,18 +675,19 @@ void QNetworkReplyHttpImplPrivate::postRequest(const QNetworkRequest &newHttpReq
     if (newHttpRequest.attribute(QNetworkRequest::FollowRedirectsAttribute).toBool())
         httpRequest.setFollowRedirects(true);
 
-    bool loadedFromCache = false;
     httpRequest.setPriority(convert(newHttpRequest.priority()));
 
     switch (operation) {
     case QNetworkAccessManager::GetOperation:
         httpRequest.setOperation(QHttpNetworkRequest::Get);
-        loadedFromCache = loadFromCacheIfAllowed(httpRequest);
+        if (loadFromCacheIfAllowed(httpRequest))
+            return; // no need to send the request! :)
         break;
 
     case QNetworkAccessManager::HeadOperation:
         httpRequest.setOperation(QHttpNetworkRequest::Head);
-        loadedFromCache = loadFromCacheIfAllowed(httpRequest);
+        if (loadFromCacheIfAllowed(httpRequest))
+            return; // no need to send the request! :)
         break;
 
     case QNetworkAccessManager::PostOperation:
@@ -718,16 +719,13 @@ void QNetworkReplyHttpImplPrivate::postRequest(const QNetworkRequest &newHttpReq
         break;                  // can't happen
     }
 
-    if (loadedFromCache) {
-        return;    // no need to send the request! :)
-    }
-
     QList<QByteArray> headers = newHttpRequest.rawHeaderList();
     if (resumeOffset != 0) {
-        if (headers.contains("Range")) {
+        const int rangeIndex = headers.indexOf("Range");
+        if (rangeIndex != -1) {
             // Need to adjust resume offset for user specified range
 
-            headers.removeOne("Range");
+            headers.removeAt(rangeIndex);
 
             // We've already verified that requestRange starts with "bytes=", see canResume.
             QByteArray requestRange = newHttpRequest.rawHeader("Range").mid(6);
@@ -749,10 +747,10 @@ void QNetworkReplyHttpImplPrivate::postRequest(const QNetworkRequest &newHttpReq
     foreach (const QByteArray &header, headers)
         httpRequest.setHeaderField(header, newHttpRequest.rawHeader(header));
 
-    if (newHttpRequest.attribute(QNetworkRequest::HttpPipeliningAllowedAttribute).toBool() == true)
+    if (newHttpRequest.attribute(QNetworkRequest::HttpPipeliningAllowedAttribute).toBool())
         httpRequest.setPipeliningAllowed(true);
 
-    if (request.attribute(QNetworkRequest::SpdyAllowedAttribute).toBool() == true)
+    if (request.attribute(QNetworkRequest::SpdyAllowedAttribute).toBool())
         httpRequest.setSPDYAllowed(true);
 
     if (static_cast<QNetworkRequest::LoadControl>
@@ -760,7 +758,7 @@ void QNetworkReplyHttpImplPrivate::postRequest(const QNetworkRequest &newHttpReq
                              QNetworkRequest::Automatic).toInt()) == QNetworkRequest::Manual)
         httpRequest.setWithCredentials(false);
 
-    if (request.attribute(QNetworkRequest::EmitAllUploadProgressSignalsAttribute).toBool() == true)
+    if (request.attribute(QNetworkRequest::EmitAllUploadProgressSignalsAttribute).toBool())
         emitAllUploadProgressSignals = true;
 
 
@@ -1747,10 +1745,8 @@ void QNetworkReplyHttpImplPrivate::_q_startOperation()
         QMetaObject::invokeMethod(q, "_q_finished", synchronous ? Qt::DirectConnection : Qt::QueuedConnection);
         return;
     }
-#endif
 
     if (!start(request)) {
-#ifndef QT_NO_BEARERMANAGEMENT
         // backend failed to start because the session state is not Connected.
         // QNetworkAccessManager will call reply->backend->start() again for us when the session
         // state changes.
@@ -1772,29 +1768,25 @@ void QNetworkReplyHttpImplPrivate::_q_startOperation()
             QMetaObject::invokeMethod(q, "_q_finished", synchronous ? Qt::DirectConnection : Qt::QueuedConnection);
             return;
         }
+    } else if (session) {
+        QObject::connect(session.data(), SIGNAL(stateChanged(QNetworkSession::State)),
+                         q, SLOT(_q_networkSessionStateChanged(QNetworkSession::State)),
+                         Qt::QueuedConnection);
+    }
 #else
+    if (!start(request)) {
         qWarning("Backend start failed");
         QMetaObject::invokeMethod(q, "_q_error", synchronous ? Qt::DirectConnection : Qt::QueuedConnection,
             Q_ARG(QNetworkReply::NetworkError, QNetworkReply::UnknownNetworkError),
             Q_ARG(QString, QCoreApplication::translate("QNetworkReply", "backend start error.")));
         QMetaObject::invokeMethod(q, "_q_finished", synchronous ? Qt::DirectConnection : Qt::QueuedConnection);
         return;
-#endif
-    } else {
-#ifndef QT_NO_BEARERMANAGEMENT
-        if (session)
-            QObject::connect(session.data(), SIGNAL(stateChanged(QNetworkSession::State)),
-                             q, SLOT(_q_networkSessionStateChanged(QNetworkSession::State)), Qt::QueuedConnection);
-#endif
     }
+#endif // QT_NO_BEARERMANAGEMENT
 
     if (synchronous) {
         state = Finished;
         q_func()->setFinished(true);
-    } else {
-        if (state != Finished) {
-
-        }
     }
 }
 
@@ -2138,15 +2130,18 @@ void QNetworkReplyHttpImplPrivate::_q_metaDataChanged()
     Q_Q(QNetworkReplyHttpImpl);
     // 1. do we have cookies?
     // 2. are we allowed to set them?
-    if (cookedHeaders.contains(QNetworkRequest::SetCookieHeader) && manager
-        && (static_cast<QNetworkRequest::LoadControl>
-            (request.attribute(QNetworkRequest::CookieSaveControlAttribute,
-                               QNetworkRequest::Automatic).toInt()) == QNetworkRequest::Automatic)) {
-        QList<QNetworkCookie> cookies =
-            qvariant_cast<QList<QNetworkCookie> >(cookedHeaders.value(QNetworkRequest::SetCookieHeader));
-        QNetworkCookieJar *jar = manager->cookieJar();
-        if (jar)
-            jar->setCookiesFromUrl(cookies, url);
+    if (manager) {
+        const auto it = cookedHeaders.constFind(QNetworkRequest::SetCookieHeader);
+        if (it != cookedHeaders.cend()
+            && request.attribute(QNetworkRequest::CookieSaveControlAttribute,
+                                 QNetworkRequest::Automatic).toInt() == QNetworkRequest::Automatic) {
+            QNetworkCookieJar *jar = manager->cookieJar();
+            if (jar) {
+                QList<QNetworkCookie> cookies =
+                    qvariant_cast<QList<QNetworkCookie> >(it.value());
+                jar->setCookiesFromUrl(cookies, url);
+            }
+        }
     }
     emit q->metaDataChanged();
 }
diff --git a/src/network/access/qnetworkreplyimpl.cpp b/src/network/access/qnetworkreplyimpl.cpp
index 0f57d1a73b9..4203169cae6 100644
--- a/src/network/access/qnetworkreplyimpl.cpp
+++ b/src/network/access/qnetworkreplyimpl.cpp
@@ -871,16 +871,20 @@ void QNetworkReplyImplPrivate::metaDataChanged()
     Q_Q(QNetworkReplyImpl);
     // 1. do we have cookies?
     // 2. are we allowed to set them?
-    if (cookedHeaders.contains(QNetworkRequest::SetCookieHeader) && !manager.isNull()
-        && (static_cast<QNetworkRequest::LoadControl>
-            (request.attribute(QNetworkRequest::CookieSaveControlAttribute,
-                               QNetworkRequest::Automatic).toInt()) == QNetworkRequest::Automatic)) {
-        QList<QNetworkCookie> cookies =
-            qvariant_cast<QList<QNetworkCookie> >(cookedHeaders.value(QNetworkRequest::SetCookieHeader));
-        QNetworkCookieJar *jar = manager->cookieJar();
-        if (jar)
-            jar->setCookiesFromUrl(cookies, url);
+    if (!manager.isNull()) {
+        const auto it = cookedHeaders.constFind(QNetworkRequest::SetCookieHeader);
+        if (it != cookedHeaders.cend()
+            && request.attribute(QNetworkRequest::CookieSaveControlAttribute,
+                                 QNetworkRequest::Automatic).toInt() == QNetworkRequest::Automatic) {
+            QNetworkCookieJar *jar = manager->cookieJar();
+            if (jar) {
+                QList<QNetworkCookie> cookies =
+                    qvariant_cast<QList<QNetworkCookie> >(it.value());
+                jar->setCookiesFromUrl(cookies, url);
+            }
+        }
     }
+
     emit q->metaDataChanged();
 }
 
diff --git a/src/network/access/qnetworkrequest.cpp b/src/network/access/qnetworkrequest.cpp
index c1889180241..f674cd5c2e7 100644
--- a/src/network/access/qnetworkrequest.cpp
+++ b/src/network/access/qnetworkrequest.cpp
@@ -806,10 +806,10 @@ static QByteArray headerValue(QNetworkRequest::KnownHeaders header, const QVaria
     return QByteArray();
 }
 
-static QNetworkRequest::KnownHeaders parseHeaderName(const QByteArray &headerName)
+static int parseHeaderName(const QByteArray &headerName)
 {
     if (headerName.isEmpty())
-        return QNetworkRequest::KnownHeaders(-1);
+        return -1;
 
     switch (tolower(headerName.at(0))) {
     case 'c':
@@ -841,7 +841,7 @@ static QNetworkRequest::KnownHeaders parseHeaderName(const QByteArray &headerNam
         break;
     }
 
-    return QNetworkRequest::KnownHeaders(-1); // nothing found
+    return -1; // nothing found
 }
 
 static QVariant parseHttpDate(const QByteArray &raw)
@@ -1012,8 +1012,10 @@ void QNetworkHeadersPrivate::setRawHeaderInternal(const QByteArray &key, const Q
 void QNetworkHeadersPrivate::parseAndSetHeader(const QByteArray &key, const QByteArray &value)
 {
     // is it a known header?
-    QNetworkRequest::KnownHeaders parsedKey = parseHeaderName(key);
-    if (parsedKey != QNetworkRequest::KnownHeaders(-1)) {
+    const int parsedKeyAsInt = parseHeaderName(key);
+    if (parsedKeyAsInt != -1) {
+        const QNetworkRequest::KnownHeaders parsedKey
+                = static_cast<QNetworkRequest::KnownHeaders>(parsedKeyAsInt);
         if (value.isNull()) {
             cookedHeaders.remove(parsedKey);
         } else if (parsedKey == QNetworkRequest::ContentLengthHeader
diff --git a/src/network/access/qspdyprotocolhandler.cpp b/src/network/access/qspdyprotocolhandler.cpp
index f3073dcd3c1..1a6dd04ecb8 100644
--- a/src/network/access/qspdyprotocolhandler.cpp
+++ b/src/network/access/qspdyprotocolhandler.cpp
@@ -872,7 +872,8 @@ void QSpdyProtocolHandler::handleSYN_REPLY(char flags, quint32 /*length*/, const
 void QSpdyProtocolHandler::parseHttpHeaders(char flags, const QByteArray &frameData)
 {
     qint32 streamID = getStreamID(frameData.constData());
-    if (!m_inFlightStreams.contains(streamID)) {
+    const auto it = m_inFlightStreams.constFind(streamID);
+    if (it == m_inFlightStreams.cend()) {
         sendRST_STREAM(streamID, RST_STREAM_INVALID_STREAM);
         return;
     }
@@ -882,7 +883,7 @@ void QSpdyProtocolHandler::parseHttpHeaders(char flags, const QByteArray &frameD
 
     QByteArray headerValuePairs = frameData.mid(4);
 
-    HttpMessagePair pair = m_inFlightStreams.value(streamID);
+    HttpMessagePair pair = it.value();
     QHttpNetworkReply *httpReply = pair.second;
     Q_ASSERT(httpReply != 0);
 
@@ -1152,12 +1153,13 @@ void QSpdyProtocolHandler::handleWINDOW_UPDATE(char /*flags*/, quint32 /*length*
     qint32 streamID = getStreamID(frameData.constData());
     qint32 deltaWindowSize = fourBytesToInt(frameData.constData() + 4);
 
-    if (!m_inFlightStreams.contains(streamID)) {
+    const auto it = m_inFlightStreams.constFind(streamID);
+    if (it == m_inFlightStreams.cend()) {
         sendRST_STREAM(streamID, RST_STREAM_INVALID_STREAM);
         return;
     }
 
-    QHttpNetworkReply *reply = m_inFlightStreams.value(streamID).second;
+    QHttpNetworkReply *reply = it.value().second;
     Q_ASSERT(reply);
     QHttpNetworkReplyPrivate *replyPrivate = reply->d_func();
     Q_ASSERT(replyPrivate);
@@ -1176,7 +1178,8 @@ void QSpdyProtocolHandler::handleDataFrame(const QByteArray &frameHeaders)
     Q_ASSERT(frameHeaders.count() >= 8);
 
     qint32 streamID = getStreamID(frameHeaders.constData());
-    if (!m_inFlightStreams.contains(streamID)) {
+    const auto it = m_inFlightStreams.constFind(streamID);
+    if (it == m_inFlightStreams.cend()) {
         sendRST_STREAM(streamID, RST_STREAM_INVALID_STREAM);
         return;
     }
@@ -1198,7 +1201,7 @@ void QSpdyProtocolHandler::handleDataFrame(const QByteArray &frameHeaders)
         m_waitingForCompleteStream = false;
     }
 
-    HttpMessagePair pair = m_inFlightStreams.value(streamID);
+    HttpMessagePair pair = it.value();
     QHttpNetworkRequest httpRequest = pair.first;
     QHttpNetworkReply *httpReply = pair.second;
     Q_ASSERT(httpReply != 0);
diff --git a/src/network/bearer/qbearerengine.cpp b/src/network/bearer/qbearerengine.cpp
index dda1229a173..215cd3fdddb 100644
--- a/src/network/bearer/qbearerengine.cpp
+++ b/src/network/bearer/qbearerengine.cpp
@@ -38,11 +38,30 @@
 ****************************************************************************/
 
 #include "qbearerengine_p.h"
+#include <algorithm>
 
 #ifndef QT_NO_BEARERMANAGEMENT
 
 QT_BEGIN_NAMESPACE
 
+static void cleanUpConfigurations(QHash<QString, QNetworkConfigurationPrivatePointer> &configurations)
+{
+    for (const auto &ptr : qAsConst(configurations)) {
+        ptr->isValid = false;
+        ptr->id.clear();
+    }
+    configurations.clear();
+}
+
+static bool hasUsedConfiguration(const QHash<QString, QNetworkConfigurationPrivatePointer> &configurations)
+{
+    auto isUsed = [](const QNetworkConfigurationPrivatePointer &ptr) {
+        return ptr->ref.load() > 1;
+    };
+    const auto end = configurations.end();
+    return std::find_if(configurations.begin(), end, isUsed) != end;
+}
+
 QBearerEngine::QBearerEngine(QObject *parent)
     : QObject(parent), mutex(QMutex::Recursive)
 {
@@ -50,28 +69,9 @@ QBearerEngine::QBearerEngine(QObject *parent)
 
 QBearerEngine::~QBearerEngine()
 {
-    QHash<QString, QNetworkConfigurationPrivatePointer>::Iterator it;
-    QHash<QString, QNetworkConfigurationPrivatePointer>::Iterator end;
-
-    for (it = snapConfigurations.begin(), end = snapConfigurations.end(); it != end; ++it) {
-        it.value()->isValid = false;
-        it.value()->id.clear();
-    }
-    snapConfigurations.clear();
-
-    for (it = accessPointConfigurations.begin(), end = accessPointConfigurations.end();
-         it != end; ++it) {
-        it.value()->isValid = false;
-        it.value()->id.clear();
-    }
-    accessPointConfigurations.clear();
-
-    for (it = userChoiceConfigurations.begin(), end = userChoiceConfigurations.end();
-         it != end; ++it) {
-        it.value()->isValid = false;
-        it.value()->id.clear();
-    }
-    userChoiceConfigurations.clear();
+    cleanUpConfigurations(snapConfigurations);
+    cleanUpConfigurations(accessPointConfigurations);
+    cleanUpConfigurations(userChoiceConfigurations);
 }
 
 bool QBearerEngine::requiresPolling() const
@@ -87,30 +87,10 @@ bool QBearerEngine::requiresPolling() const
 */
 bool QBearerEngine::configurationsInUse() const
 {
-    QHash<QString, QNetworkConfigurationPrivatePointer>::ConstIterator it;
-    QHash<QString, QNetworkConfigurationPrivatePointer>::ConstIterator end;
-
     QMutexLocker locker(&mutex);
-
-    for (it = accessPointConfigurations.constBegin(),
-         end = accessPointConfigurations.constEnd(); it != end; ++it) {
-        if (it.value()->ref.load() > 1)
-            return true;
-    }
-
-    for (it = snapConfigurations.constBegin(),
-         end = snapConfigurations.constEnd(); it != end; ++it) {
-        if (it.value()->ref.load() > 1)
-            return true;
-    }
-
-    for (it = userChoiceConfigurations.constBegin(),
-         end = userChoiceConfigurations.constEnd(); it != end; ++it) {
-        if (it.value()->ref.load() > 1)
-            return true;
-    }
-
-    return false;
+    return hasUsedConfiguration(accessPointConfigurations)
+        || hasUsedConfiguration(snapConfigurations)
+        || hasUsedConfiguration(userChoiceConfigurations);
 }
 
 #include "moc_qbearerengine_p.cpp"
diff --git a/src/network/bearer/qnetworkconfigmanager_p.cpp b/src/network/bearer/qnetworkconfigmanager_p.cpp
index 3101a981657..232875f43c7 100644
--- a/src/network/bearer/qnetworkconfigmanager_p.cpp
+++ b/src/network/bearer/qnetworkconfigmanager_p.cpp
@@ -52,6 +52,8 @@
 #include <QtCore/qbytearray.h>
 #include <QtCore/qglobal.h>
 
+#include <utility>
+
 
 #ifndef QT_NO_BEARERMANAGEMENT
 
@@ -263,17 +265,18 @@ QNetworkConfiguration QNetworkConfigurationManagerPrivate::configurationFromIden
 
     foreach (QBearerEngine *engine, sessionEngines) {
         QMutexLocker locker(&engine->mutex);
-
-        if (engine->accessPointConfigurations.contains(identifier))
-            item.d = engine->accessPointConfigurations[identifier];
-        else if (engine->snapConfigurations.contains(identifier))
-            item.d = engine->snapConfigurations[identifier];
-        else if (engine->userChoiceConfigurations.contains(identifier))
-            item.d = engine->userChoiceConfigurations[identifier];
-        else
-            continue;
-
-        return item;
+        if (auto ptr = engine->accessPointConfigurations.value(identifier)) {
+            item.d = std::move(ptr);
+            break;
+        }
+        if (auto ptr = engine->snapConfigurations.value(identifier)) {
+            item.d = std::move(ptr);
+            break;
+        }
+        if (auto ptr = engine->userChoiceConfigurations.value(identifier)) {
+            item.d = std::move(ptr);
+            break;
+        }
     }
 
     return item;
diff --git a/src/network/bearer/qsharednetworksession.cpp b/src/network/bearer/qsharednetworksession.cpp
index e04c8cc953d..fc01acb8b4a 100644
--- a/src/network/bearer/qsharednetworksession.cpp
+++ b/src/network/bearer/qsharednetworksession.cpp
@@ -65,9 +65,10 @@ static void doDeleteLater(QObject* obj)
 QSharedPointer<QNetworkSession> QSharedNetworkSessionManager::getSession(const QNetworkConfiguration &config)
 {
     QSharedNetworkSessionManager *m(sharedNetworkSessionManager());
+    const auto it = m->sessions.constFind(config);
     //if already have a session, return it
-    if (m->sessions.contains(config)) {
-        QSharedPointer<QNetworkSession> p = m->sessions.value(config).toStrongRef();
+    if (it != m->sessions.cend()) {
+        QSharedPointer<QNetworkSession> p = it.value().toStrongRef();
         if (!p.isNull())
             return p;
     }
diff --git a/src/network/kernel/kernel.pri b/src/network/kernel/kernel.pri
index 841a71643a4..811d8b6f0df 100644
--- a/src/network/kernel/kernel.pri
+++ b/src/network/kernel/kernel.pri
@@ -26,7 +26,10 @@ SOURCES += kernel/qauthenticator.cpp \
            kernel/qnetworkproxy.cpp \
 	   kernel/qnetworkinterface.cpp
 
-unix:SOURCES += kernel/qdnslookup_unix.cpp kernel/qhostinfo_unix.cpp kernel/qnetworkinterface_unix.cpp
+unix {
+    !integrity: SOURCES += kernel/qdnslookup_unix.cpp
+    SOURCES += kernel/qhostinfo_unix.cpp kernel/qnetworkinterface_unix.cpp
+}
 
 android {
     SOURCES -= kernel/qdnslookup_unix.cpp
@@ -47,7 +50,6 @@ win32: {
                    kernel/qnetworkinterface_winrt.cpp
     }
 }
-integrity:SOURCES += kernel/qdnslookup_unix.cpp kernel/qhostinfo_unix.cpp kernel/qnetworkinterface_unix.cpp
 
 mac {
     LIBS_PRIVATE += -framework SystemConfiguration -framework CoreFoundation
diff --git a/src/network/kernel/qdnslookup_winrt.cpp b/src/network/kernel/qdnslookup_winrt.cpp
index a0643c5daa1..b459deb1ed6 100644
--- a/src/network/kernel/qdnslookup_winrt.cpp
+++ b/src/network/kernel/qdnslookup_winrt.cpp
@@ -65,7 +65,7 @@ void QDnsLookupRunnable::query(const int requestType, const QByteArray &requestN
 {
     // TODO: Add nameserver support for winRT
     if (!nameserver.isNull())
-        qWarning() << "Ignoring nameserver as its currently not supported on WinRT";
+        qWarning("Ignoring nameserver as its currently not supported on WinRT");
 
     // TODO: is there any way to do "proper" dns lookup?
     if (requestType != QDnsLookup::A && requestType != QDnsLookup::AAAA
diff --git a/src/network/kernel/qhostaddress.cpp b/src/network/kernel/qhostaddress.cpp
index fc2038cf032..6ccf40680a4 100644
--- a/src/network/kernel/qhostaddress.cpp
+++ b/src/network/kernel/qhostaddress.cpp
@@ -737,24 +737,17 @@ Q_IPV6ADDR QHostAddress::toIPv6Address() const
 QString QHostAddress::toString() const
 {
     QT_ENSURE_PARSED(this);
+    QString s;
     if (d->protocol == QAbstractSocket::IPv4Protocol
         || d->protocol == QAbstractSocket::AnyIPProtocol) {
         quint32 i = toIPv4Address();
-        QString s;
         QIPAddressUtils::toString(s, i);
-        return s;
-    }
-
-    if (d->protocol == QAbstractSocket::IPv6Protocol) {
-        QString s;
+    } else if (d->protocol == QAbstractSocket::IPv6Protocol) {
         QIPAddressUtils::toString(s, d->a6.c);
-
         if (!d->scopeId.isEmpty())
             s.append(QLatin1Char('%') + d->scopeId);
-        return s;
     }
-
-    return QString();
+    return s;
 }
 
 /*!
diff --git a/src/network/kernel/qhostinfo.cpp b/src/network/kernel/qhostinfo.cpp
index cba0ab65b6f..293633d6bc6 100644
--- a/src/network/kernel/qhostinfo.cpp
+++ b/src/network/kernel/qhostinfo.cpp
@@ -49,6 +49,8 @@
 #include <qurl.h>
 #include <private/qnetworksession_p.h>
 
+#include <algorithm>
+
 #ifdef Q_OS_UNIX
 #  include <unistd.h>
 #endif
@@ -59,6 +61,26 @@ QT_BEGIN_NAMESPACE
 
 Q_GLOBAL_STATIC(QHostInfoLookupManager, theHostInfoLookupManager)
 
+namespace {
+struct ToBeLookedUpEquals {
+    typedef bool result_type;
+    explicit ToBeLookedUpEquals(const QString &toBeLookedUp) Q_DECL_NOTHROW : m_toBeLookedUp(toBeLookedUp) {}
+    result_type operator()(QHostInfoRunnable* lookup) const Q_DECL_NOTHROW
+    {
+        return m_toBeLookedUp == lookup->toBeLookedUp;
+    }
+private:
+    QString m_toBeLookedUp;
+};
+
+// ### C++11: remove once we can use std::any_of()
+template<class InputIt, class UnaryPredicate>
+bool any_of(InputIt first, InputIt last, UnaryPredicate p)
+{
+    return std::find_if(first, last, p) != last;
+}
+}
+
 /*!
     \class QHostInfo
     \brief The QHostInfo class provides static functions for host name lookups.
@@ -496,17 +518,17 @@ void QHostInfoRunnable::run()
     // now also iterate through the postponed ones
     {
         QMutexLocker locker(&manager->mutex);
-        QMutableListIterator<QHostInfoRunnable*> iterator(manager->postponedLookups);
-        while (iterator.hasNext()) {
-            QHostInfoRunnable* postponed = iterator.next();
-            if (toBeLookedUp == postponed->toBeLookedUp) {
-                // we can now emit
-                iterator.remove();
-                hostInfo.setLookupId(postponed->id);
-                postponed->resultEmitter.emitResultsReady(hostInfo);
-                delete postponed;
-            }
+        const auto partitionBegin = std::stable_partition(manager->postponedLookups.rbegin(), manager->postponedLookups.rend(),
+                                                          ToBeLookedUpEquals(toBeLookedUp)).base();
+        const auto partitionEnd = manager->postponedLookups.end();
+        for (auto it = partitionBegin; it != partitionEnd; ++it) {
+            QHostInfoRunnable* postponed = *it;
+            // we can now emit
+            hostInfo.setLookupId(postponed->id);
+            postponed->resultEmitter.emitResultsReady(hostInfo);
+            delete postponed;
         }
+        manager->postponedLookups.erase(partitionBegin, partitionEnd);
     }
 
     manager->lookupFinished(this);
@@ -573,13 +595,7 @@ void QHostInfoLookupManager::work()
             QHostInfoRunnable* postponed = iterator.next();
 
             // check if none of the postponed hostnames is currently running
-            bool alreadyRunning = false;
-            for (int i = 0; i < currentLookups.length(); i++) {
-                if (currentLookups.at(i)->toBeLookedUp == postponed->toBeLookedUp) {
-                    alreadyRunning = true;
-                    break;
-                }
-            }
+            const bool alreadyRunning = any_of(currentLookups.cbegin(), currentLookups.cend(), ToBeLookedUpEquals(postponed->toBeLookedUp));
             if (!alreadyRunning) {
                 iterator.remove();
                 scheduledLookups.prepend(postponed); // prepend! we want to finish it ASAP
@@ -594,13 +610,11 @@ void QHostInfoLookupManager::work()
             QHostInfoRunnable *scheduled = iterator.next();
 
             // check if a lookup for this host is already running, then postpone
-            for (int i = 0; i < currentLookups.size(); i++) {
-                if (currentLookups.at(i)->toBeLookedUp == scheduled->toBeLookedUp) {
-                    iterator.remove();
-                    postponedLookups.append(scheduled);
-                    scheduled = 0;
-                    break;
-                }
+            const bool alreadyRunning = any_of(currentLookups.cbegin(), currentLookups.cend(), ToBeLookedUpEquals(scheduled->toBeLookedUp));
+            if (alreadyRunning) {
+                iterator.remove();
+                postponedLookups.append(scheduled);
+                scheduled = 0;
             }
 
             if (scheduled && currentLookups.size() < threadPool.maxThreadCount()) {
diff --git a/src/network/kernel/qnetworkproxy_generic.cpp b/src/network/kernel/qnetworkproxy_generic.cpp
index 272d6dfe8d1..db1083f3e09 100644
--- a/src/network/kernel/qnetworkproxy_generic.cpp
+++ b/src/network/kernel/qnetworkproxy_generic.cpp
@@ -112,16 +112,17 @@ QList<QNetworkProxy> QNetworkProxyFactory::systemProxyForQuery(const QNetworkPro
 
     if (!proxy_env.isEmpty()) {
         QUrl url = QUrl(QString::fromLocal8Bit(proxy_env));
-        if (url.scheme() == QLatin1String("socks5")) {
+        const QString scheme = url.scheme();
+        if (scheme == QLatin1String("socks5")) {
             QNetworkProxy proxy(QNetworkProxy::Socks5Proxy, url.host(),
                     url.port() ? url.port() : 1080, url.userName(), url.password());
             proxyList << proxy;
-        } else if (url.scheme() == QLatin1String("socks5h")) {
+        } else if (scheme == QLatin1String("socks5h")) {
             QNetworkProxy proxy(QNetworkProxy::Socks5Proxy, url.host(),
                     url.port() ? url.port() : 1080, url.userName(), url.password());
             proxy.setCapabilities(QNetworkProxy::HostNameLookupCapability);
             proxyList << proxy;
-        } else if ((url.scheme() == QLatin1String("http") || url.scheme().isEmpty())
+        } else if ((scheme.isEmpty() || scheme == QLatin1String("http"))
                   && query.queryType() != QNetworkProxyQuery::UdpSocket
                   && query.queryType() != QNetworkProxyQuery::TcpServer) {
             QNetworkProxy proxy(QNetworkProxy::HttpProxy, url.host(),
diff --git a/src/network/network.pro b/src/network/network.pro
index 4cced923f7a..cdea1902221 100644
--- a/src/network/network.pro
+++ b/src/network/network.pro
@@ -11,13 +11,8 @@ DEFINES += QT_NO_USING_NAMESPACE
 #DEFINES += QUDPSOCKET_DEBUG QUDPSERVER_DEBUG
 win32-msvc*|win32-icc:QMAKE_LFLAGS += /BASE:0x64000000
 
-MODULE_PLUGIN_TYPES = \
-    bearer
-
 QMAKE_DOCS = $$PWD/doc/qtnetwork.qdocconf
 
-load(qt_module)
-
 include(access/access.pri)
 include(bearer/bearer.pri)
 include(kernel/kernel.pri)
@@ -36,3 +31,7 @@ MODULE_PLUGIN_TYPES = \
     bearer
 ANDROID_PERMISSIONS += \
     android.permission.ACCESS_NETWORK_STATE
+
+MODULE_PLUGIN_TYPES = \
+    bearer
+load(qt_module)
diff --git a/src/network/socket/qabstractsocket.cpp b/src/network/socket/qabstractsocket.cpp
index 0969d841806..3ce2d63a396 100644
--- a/src/network/socket/qabstractsocket.cpp
+++ b/src/network/socket/qabstractsocket.cpp
@@ -562,7 +562,6 @@ QAbstractSocketPrivate::QAbstractSocketPrivate()
       socketEngine(0),
       cachedSocketDescriptor(-1),
       readBufferMaxSize(0),
-      writeBuffer(QABSTRACTSOCKET_BUFFERSIZE),
       isBuffered(false),
       connectTimer(0),
       disconnectTimer(0),
@@ -572,6 +571,7 @@ QAbstractSocketPrivate::QAbstractSocketPrivate()
       socketError(QAbstractSocket::UnknownSocketError),
       preferredNetworkLayerProtocol(QAbstractSocket::UnknownNetworkLayerProtocol)
 {
+    writeBufferChunkSize = QABSTRACTSOCKET_BUFFERSIZE;
 }
 
 /*! \internal
@@ -852,15 +852,16 @@ bool QAbstractSocketPrivate::writeToSocket()
            written);
 #endif
 
-    // Remove what we wrote so far.
-    writeBuffer.free(written);
     if (written > 0) {
+        // Remove what we wrote so far.
+        writeBuffer.free(written);
         // Don't emit bytesWritten() recursively.
         if (!emittedBytesWritten) {
             QScopedValueRollback<bool> r(emittedBytesWritten);
             emittedBytesWritten = true;
             emit q->bytesWritten(written);
         }
+        emit q->channelBytesWritten(0, written);
     }
 
     if (writeBuffer.isEmpty() && socketEngine && !socketEngine->bytesToWrite())
@@ -1286,6 +1287,7 @@ void QAbstractSocketPrivate::emitReadyRead()
         emittedReadyRead = true;
         emit q->readyRead();
     }
+    emit q->channelReadyRead(0);
 }
 
 /*! \internal
@@ -1298,6 +1300,18 @@ void QAbstractSocketPrivate::fetchConnectionParameters()
 
     peerName = hostName;
     if (socketEngine) {
+        if (q->isReadable()) {
+            const int inboundStreamCount = socketEngine->inboundStreamCount();
+            setReadChannelCount(qMax(1, inboundStreamCount));
+            if (inboundStreamCount == 0)
+                readChannelCount = 0;
+        }
+        if (q->isWritable()) {
+            const int outboundStreamCount = socketEngine->outboundStreamCount();
+            setWriteChannelCount(qMax(1, outboundStreamCount));
+            if (outboundStreamCount == 0)
+                writeChannelCount = 0;
+        }
         socketEngine->setReadNotificationEnabled(true);
         socketEngine->setWriteNotificationEnabled(true);
         localPort = socketEngine->localPort();
@@ -1620,8 +1634,8 @@ void QAbstractSocket::connectToHost(const QString &hostName, quint16 port,
     d->preferredNetworkLayerProtocol = protocol;
     d->hostName = hostName;
     d->port = port;
-    d->buffer.clear();
-    d->writeBuffer.clear();
+    d->setReadChannelCount(0);
+    d->setWriteChannelCount(0);
     d->abortCalled = false;
     d->pendingClose = false;
     if (d->state != BoundState) {
@@ -1654,6 +1668,8 @@ void QAbstractSocket::connectToHost(const QString &hostName, quint16 port,
         openMode |= QAbstractSocket::Unbuffered; // QUdpSocket
 
     QIODevice::open(openMode);
+    d->readChannelCount = d->writeChannelCount = 0;
+
     d->state = HostLookupState;
     emit stateChanged(d->state);
 
@@ -1716,11 +1732,11 @@ void QAbstractSocket::connectToHost(const QHostAddress &address, quint16 port,
 */
 qint64 QAbstractSocket::bytesToWrite() const
 {
-    Q_D(const QAbstractSocket);
+    const qint64 pendingBytes = QIODevice::bytesToWrite();
 #if defined(QABSTRACTSOCKET_DEBUG)
-    qDebug("QAbstractSocket::bytesToWrite() == %lld", d->writeBuffer.size());
+    qDebug("QAbstractSocket::bytesToWrite() == %lld", pendingBytes);
 #endif
-    return d->writeBuffer.size();
+    return pendingBytes;
 }
 
 /*!
@@ -1859,8 +1875,8 @@ bool QAbstractSocket::setSocketDescriptor(qintptr socketDescriptor, SocketState
     Q_D(QAbstractSocket);
 
     d->resetSocketLayer();
-    d->writeBuffer.clear();
-    d->buffer.clear();
+    d->setReadChannelCount(0);
+    d->setWriteChannelCount(0);
     d->socketEngine = QAbstractSocketEngine::createSocketEngine(socketDescriptor, this);
     if (!d->socketEngine) {
         d->setError(UnsupportedSocketOperationError, tr("Operation on socket is not supported"));
@@ -1881,6 +1897,23 @@ bool QAbstractSocket::setSocketDescriptor(qintptr socketDescriptor, SocketState
 
     QIODevice::open(openMode);
 
+    if (socketState == ConnectedState) {
+        if (isReadable()) {
+            const int inboundStreamCount = d->socketEngine->inboundStreamCount();
+            d->setReadChannelCount(qMax(1, inboundStreamCount));
+            if (inboundStreamCount == 0)
+                d->readChannelCount = 0;
+        }
+        if (isWritable()) {
+            const int outboundStreamCount = d->socketEngine->outboundStreamCount();
+            d->setWriteChannelCount(qMax(1, outboundStreamCount));
+            if (outboundStreamCount == 0)
+                d->writeChannelCount = 0;
+        }
+    } else {
+        d->readChannelCount = d->writeChannelCount = 0;
+    }
+
     if (d->state != socketState) {
         d->state = socketState;
         emit stateChanged(d->state);
@@ -2138,8 +2171,10 @@ bool QAbstractSocket::waitForReadyRead(int msecs)
             return false;
     }
 
-    Q_ASSERT(d->socketEngine);
     do {
+        if (state() != ConnectedState)
+            return false;
+
         bool readyToRead = false;
         bool readyToWrite = false;
         if (!d->socketEngine->waitForReadOrWrite(&readyToRead, &readyToWrite, true, !d->writeBuffer.isEmpty(),
@@ -2161,9 +2196,6 @@ bool QAbstractSocket::waitForReadyRead(int msecs)
 
         if (readyToWrite)
             d->canWriteNotification();
-
-        if (state() != ConnectedState)
-            return false;
     } while (msecs == -1 || qt_subtract_from_timeout(msecs, stopWatch.elapsed()) > 0);
     return false;
 }
@@ -2212,8 +2244,10 @@ bool QAbstractSocket::waitForBytesWritten(int msecs)
     forever {
         bool readyToRead = false;
         bool readyToWrite = false;
-        if (!d->socketEngine->waitForReadOrWrite(&readyToRead, &readyToWrite, true, !d->writeBuffer.isEmpty(),
-                                               qt_subtract_from_timeout(msecs, stopWatch.elapsed()))) {
+        if (!d->socketEngine->waitForReadOrWrite(&readyToRead, &readyToWrite,
+                                  !d->readBufferMaxSize || d->buffer.size() < d->readBufferMaxSize,
+                                  !d->writeBuffer.isEmpty(),
+                                  qt_subtract_from_timeout(msecs, stopWatch.elapsed()))) {
 #if defined (QABSTRACTSOCKET_DEBUG)
             qDebug("QAbstractSocket::waitForBytesWritten(%i) failed (%i, %s)",
                    msecs, d->socketEngine->error(), d->socketEngine->errorString().toLatin1().constData());
@@ -2228,8 +2262,7 @@ bool QAbstractSocket::waitForBytesWritten(int msecs)
 #if defined (QABSTRACTSOCKET_DEBUG)
             qDebug("QAbstractSocket::waitForBytesWritten calls canReadNotification");
 #endif
-            if(!d->canReadNotification())
-                return false;
+            d->canReadNotification();
         }
 
 
@@ -2328,7 +2361,7 @@ void QAbstractSocket::abort()
 #if defined (QABSTRACTSOCKET_DEBUG)
     qDebug("QAbstractSocket::abort()");
 #endif
-    d->writeBuffer.clear();
+    d->setWriteChannelCount(0);
     if (d->state == UnconnectedState)
         return;
 #ifndef QT_NO_SSL
@@ -2472,8 +2505,10 @@ qint64 QAbstractSocket::writeData(const char *data, qint64 size)
            qt_prettyDebug(data, qMin((int)size, 32), size).data(),
            size, written);
 #endif
-        if (written >= 0)
+        if (written >= 0) {
             emit bytesWritten(written);
+            emit channelBytesWritten(0, written);
+        }
         return written;
     }
 
@@ -2724,7 +2759,7 @@ void QAbstractSocket::disconnectFromHost()
     d->peerPort = 0;
     d->localAddress.clear();
     d->peerAddress.clear();
-    d->writeBuffer.clear();
+    d->setWriteChannelCount(0);
 
 #if defined(QABSTRACTSOCKET_DEBUG)
         qDebug("QAbstractSocket::disconnectFromHost() disconnected!");
diff --git a/src/network/socket/qabstractsocket_p.h b/src/network/socket/qabstractsocket_p.h
index a5c3fb619b1..ab642e039b9 100644
--- a/src/network/socket/qabstractsocket_p.h
+++ b/src/network/socket/qabstractsocket_p.h
@@ -55,7 +55,6 @@
 #include "QtCore/qbytearray.h"
 #include "QtCore/qlist.h"
 #include "QtCore/qtimer.h"
-#include "private/qringbuffer_p.h"
 #include "private/qiodevice_p.h"
 #include "private/qabstractsocketengine_p.h"
 #include "qnetworkproxy.h"
@@ -143,8 +142,6 @@ public:
     void setErrorAndEmit(QAbstractSocket::SocketError errorCode, const QString &errorString);
 
     qint64 readBufferMaxSize;
-    QRingBuffer writeBuffer;
-
     bool isBuffered;
 
     QTimer *connectTimer;
diff --git a/src/network/socket/qabstractsocketengine.cpp b/src/network/socket/qabstractsocketengine.cpp
index d40a3a64a7b..3fffff6d5a7 100644
--- a/src/network/socket/qabstractsocketengine.cpp
+++ b/src/network/socket/qabstractsocketengine.cpp
@@ -83,6 +83,8 @@ QAbstractSocketEnginePrivate::QAbstractSocketEnginePrivate()
     , socketProtocol(QAbstractSocket::UnknownNetworkLayerProtocol)
     , localPort(0)
     , peerPort(0)
+    , inboundStreamCount(0)
+    , outboundStreamCount(0)
     , receiver(0)
 {
 }
@@ -261,4 +263,14 @@ void QAbstractSocketEngine::setPeerPort(quint16 port)
     d_func()->peerPort = port;
 }
 
+int QAbstractSocketEngine::inboundStreamCount() const
+{
+    return d_func()->inboundStreamCount;
+}
+
+int QAbstractSocketEngine::outboundStreamCount() const
+{
+    return d_func()->outboundStreamCount;
+}
+
 QT_END_NAMESPACE
diff --git a/src/network/socket/qabstractsocketengine_p.h b/src/network/socket/qabstractsocketengine_p.h
index 945e205cfb8..0073a8b1f2b 100644
--- a/src/network/socket/qabstractsocketengine_p.h
+++ b/src/network/socket/qabstractsocketengine_p.h
@@ -174,6 +174,8 @@ public:
     quint16 localPort() const;
     QHostAddress peerAddress() const;
     quint16 peerPort() const;
+    int inboundStreamCount() const;
+    int outboundStreamCount() const;
 
     virtual bool isReadNotificationEnabled() const = 0;
     virtual void setReadNotificationEnabled(bool enable) = 0;
@@ -227,6 +229,8 @@ public:
     quint16 localPort;
     QHostAddress peerAddress;
     quint16 peerPort;
+    int inboundStreamCount;
+    int outboundStreamCount;
     QAbstractSocketEngineReceiver *receiver;
 };
 
diff --git a/src/network/socket/qhttpsocketengine.cpp b/src/network/socket/qhttpsocketengine.cpp
index 942d19c1b34..642c9bb10f7 100644
--- a/src/network/socket/qhttpsocketengine.cpp
+++ b/src/network/socket/qhttpsocketengine.cpp
@@ -510,7 +510,7 @@ void QHttpSocketEngine::slotSocketConnected()
     data += "\r\n";
 //     qDebug() << ">>>>>>>> sending request" << this;
 //     qDebug() << data;
-//     qDebug() << ">>>>>>>";
+//     qDebug(">>>>>>>");
     d->socket->write(data);
     d->state = ConnectSent;
 }
@@ -576,6 +576,7 @@ void QHttpSocketEngine::slotSocketReadNotification()
         d->state = Connected;
         setLocalAddress(d->socket->localAddress());
         setLocalPort(d->socket->localPort());
+        d->inboundStreamCount = d->outboundStreamCount = 1;
         setState(QAbstractSocket::ConnectedState);
         d->authenticator.detach();
         priv = QAuthenticatorPrivate::getPrivate(d->authenticator);
diff --git a/src/network/socket/qlocalserver_win.cpp b/src/network/socket/qlocalserver_win.cpp
index c2812e54f8e..8cb3449343f 100644
--- a/src/network/socket/qlocalserver_win.cpp
+++ b/src/network/socket/qlocalserver_win.cpp
@@ -198,6 +198,9 @@ bool QLocalServerPrivate::addListener()
 
     memset(&listener.overlapped, 0, sizeof(listener.overlapped));
     listener.overlapped.hEvent = eventHandle;
+
+    // Beware! ConnectNamedPipe will reset the eventHandle to non-signaled.
+    // Callers of addListener must check all listeners for connections.
     if (!ConnectNamedPipe(listener.handle, &listener.overlapped)) {
         switch (GetLastError()) {
         case ERROR_IO_PENDING:
@@ -205,7 +208,6 @@ bool QLocalServerPrivate::addListener()
             break;
         case ERROR_PIPE_CONNECTED:
             listener.connected = true;
-            SetEvent(eventHandle);
             break;
         default:
             CloseHandle(listener.handle);
@@ -241,7 +243,7 @@ bool QLocalServerPrivate::listen(const QString &name)
 {
     Q_Q(QLocalServer);
 
-    QString pipePath = QLatin1String("\\\\.\\pipe\\");
+    const QLatin1String pipePath("\\\\.\\pipe\\");
     if (name.startsWith(pipePath))
         fullServerName = name;
     else
@@ -257,6 +259,8 @@ bool QLocalServerPrivate::listen(const QString &name)
     for (int i = 0; i < SYSTEM_MAX_PENDING_SOCKETS; ++i)
         if (!addListener())
             return false;
+
+    _q_onNewConnection();
     return true;
 }
 
@@ -270,37 +274,43 @@ void QLocalServerPrivate::_q_onNewConnection()
 {
     Q_Q(QLocalServer);
     DWORD dummy;
+    bool tryAgain;
+    do {
+        tryAgain = false;
 
-    // Reset first, otherwise we could reset an event which was asserted
-    // immediately after we checked the conn status.
-    ResetEvent(eventHandle);
+        // Reset first, otherwise we could reset an event which was asserted
+        // immediately after we checked the conn status.
+        ResetEvent(eventHandle);
 
-    // Testing shows that there is indeed absolutely no guarantee which listener gets
-    // a client connection first, so there is no way around polling all of them.
-    for (int i = 0; i < listeners.size(); ) {
-        HANDLE handle = listeners[i].handle;
-        if (listeners[i].connected
-            || GetOverlappedResult(handle, &listeners[i].overlapped, &dummy, FALSE))
-        {
-            listeners.removeAt(i);
+        // Testing shows that there is indeed absolutely no guarantee which listener gets
+        // a client connection first, so there is no way around polling all of them.
+        for (int i = 0; i < listeners.size(); ) {
+            HANDLE handle = listeners[i].handle;
+            if (listeners[i].connected
+                || GetOverlappedResult(handle, &listeners[i].overlapped, &dummy, FALSE))
+            {
+                listeners.removeAt(i);
 
-            addListener();
+                addListener();
 
-            if (pendingConnections.size() > maxPendingConnections)
-                connectionEventNotifier->setEnabled(false);
+                if (pendingConnections.size() > maxPendingConnections)
+                    connectionEventNotifier->setEnabled(false);
+                else
+                    tryAgain = true;
 
-            // Make this the last thing so connected slots can wreak the least havoc
-            q->incomingConnection((quintptr)handle);
-        } else {
-            if (GetLastError() != ERROR_IO_INCOMPLETE) {
-                q->close();
-                setError(QLatin1String("QLocalServerPrivate::_q_onNewConnection"));
-                return;
+                // Make this the last thing so connected slots can wreak the least havoc
+                q->incomingConnection((quintptr)handle);
+            } else {
+                if (GetLastError() != ERROR_IO_INCOMPLETE) {
+                    q->close();
+                    setError(QLatin1String("QLocalServerPrivate::_q_onNewConnection"));
+                    return;
+                }
+
+                ++i;
             }
-
-            ++i;
         }
-    }
+    } while (tryAgain);
 }
 
 void QLocalServerPrivate::closeServer()
diff --git a/src/network/socket/qlocalsocket_win.cpp b/src/network/socket/qlocalsocket_win.cpp
index 4e8ae41479d..7f9b8a7b069 100644
--- a/src/network/socket/qlocalsocket_win.cpp
+++ b/src/network/socket/qlocalsocket_win.cpp
@@ -148,7 +148,7 @@ void QLocalSocket::connectToServer(OpenMode openMode)
         return;
     }
 
-    QString pipePath = QLatin1String("\\\\.\\pipe\\");
+    const QLatin1String pipePath("\\\\.\\pipe\\");
     if (d->serverName.startsWith(pipePath))
         d->fullServerName = d->serverName;
     else
@@ -220,7 +220,6 @@ qint64 QLocalSocket::writeData(const char *data, qint64 maxSize)
         d->pipeWriter = new QWindowsPipeWriter(d->handle, this);
         connect(d->pipeWriter, SIGNAL(canWrite()), this, SLOT(_q_canWrite()));
         connect(d->pipeWriter, SIGNAL(bytesWritten(qint64)), this, SIGNAL(bytesWritten(qint64)));
-        d->pipeWriter->start();
     }
     return d->pipeWriter->write(data, maxSize);
 }
diff --git a/src/network/socket/qnativesocketengine.cpp b/src/network/socket/qnativesocketengine.cpp
index eefc0792aad..4063a225fbc 100644
--- a/src/network/socket/qnativesocketengine.cpp
+++ b/src/network/socket/qnativesocketengine.cpp
@@ -922,6 +922,7 @@ void QNativeSocketEngine::close()
     d->localAddress.clear();
     d->peerPort = 0;
     d->peerAddress.clear();
+    d->inboundStreamCount = d->outboundStreamCount = 0;
     if (d->readNotifier) {
         qDeleteInEventHandler(d->readNotifier);
         d->readNotifier = 0;
diff --git a/src/network/socket/qnativesocketengine_unix.cpp b/src/network/socket/qnativesocketengine_unix.cpp
index 1a3e2a5cae0..de091753d26 100644
--- a/src/network/socket/qnativesocketengine_unix.cpp
+++ b/src/network/socket/qnativesocketengine_unix.cpp
@@ -1027,6 +1027,7 @@ bool QNativeSocketEnginePrivate::fetchConnectionParameters()
     localAddress.clear();
     peerPort = 0;
     peerAddress.clear();
+    inboundStreamCount = outboundStreamCount = 0;
 
     if (socketDescriptor == -1)
         return false;
@@ -1077,8 +1078,10 @@ bool QNativeSocketEnginePrivate::fetchConnectionParameters()
 #endif
 
     // Determine the remote address
-    if (!::getpeername(socketDescriptor, &sa.a, &sockAddrSize))
+    if (!::getpeername(socketDescriptor, &sa.a, &sockAddrSize)) {
         qt_socket_getPortAndAddress(&sa, &peerPort, &peerAddress);
+        inboundStreamCount = outboundStreamCount = 1;
+    }
 
     // Determine the socket type (UDP/TCP)
     int value = 0;
@@ -1101,10 +1104,10 @@ bool QNativeSocketEnginePrivate::fetchConnectionParameters()
     else if (socketType == QAbstractSocket::UdpSocket) socketTypeStr = QStringLiteral("UdpSocket");
 
     qDebug("QNativeSocketEnginePrivate::fetchConnectionParameters() local == %s:%i,"
-           " peer == %s:%i, socket == %s - %s",
+           " peer == %s:%i, socket == %s - %s, inboundStreamCount == %i, outboundStreamCount == %i",
            localAddress.toString().toLatin1().constData(), localPort,
            peerAddress.toString().toLatin1().constData(), peerPort,socketTypeStr.toLatin1().constData(),
-           socketProtocolStr.toLatin1().constData());
+           socketProtocolStr.toLatin1().constData(), inboundStreamCount, outboundStreamCount);
 #endif
     return true;
 }
diff --git a/src/network/socket/qnativesocketengine_win.cpp b/src/network/socket/qnativesocketengine_win.cpp
index 20f7ab26225..648f2bf376e 100644
--- a/src/network/socket/qnativesocketengine_win.cpp
+++ b/src/network/socket/qnativesocketengine_win.cpp
@@ -528,6 +528,7 @@ bool QNativeSocketEnginePrivate::fetchConnectionParameters()
     localAddress.clear();
     peerPort = 0;
     peerAddress.clear();
+    inboundStreamCount = outboundStreamCount = 0;
 
     if (socketDescriptor == -1)
        return false;
@@ -576,6 +577,7 @@ bool QNativeSocketEnginePrivate::fetchConnectionParameters()
     memset(&sa, 0, sizeof(sa));
     if (::getpeername(socketDescriptor, &sa.a, &sockAddrSize) == 0) {
         qt_socket_getPortAndAddress(socketDescriptor, &sa, &peerPort, &peerAddress);
+        inboundStreamCount = outboundStreamCount = 1;
     } else {
         WS_ERROR_DEBUG(WSAGetLastError());
     }
diff --git a/src/network/socket/qnativesocketengine_winrt.cpp b/src/network/socket/qnativesocketengine_winrt.cpp
index 68ee1e52d56..0f632abbb39 100644
--- a/src/network/socket/qnativesocketengine_winrt.cpp
+++ b/src/network/socket/qnativesocketengine_winrt.cpp
@@ -480,6 +480,7 @@ void QNativeSocketEngine::close()
     d->localAddress.clear();
     d->peerPort = 0;
     d->peerAddress.clear();
+    d->inboundStreamCount = d->outboundStreamCount = 0;
 }
 
 bool QNativeSocketEngine::joinMulticastGroup(const QHostAddress &groupAddress, const QNetworkInterface &iface)
@@ -1082,6 +1083,7 @@ bool QNativeSocketEnginePrivate::fetchConnectionParameters()
     localAddress.clear();
     peerPort = 0;
     peerAddress.clear();
+    inboundStreamCount = outboundStreamCount = 0;
 
     HRESULT hr;
     if (socketType == QAbstractSocket::TcpSocket) {
@@ -1117,6 +1119,7 @@ bool QNativeSocketEnginePrivate::fetchConnectionParameters()
             hr = info->get_RemotePort(tmpHString.GetAddressOf());
             Q_ASSERT_SUCCEEDED(hr);
             peerPort = qt_QStringFromHString(tmpHString).toInt();
+            inboundStreamCount = outboundStreamCount = 1;
         }
     } else if (socketType == QAbstractSocket::UdpSocket) {
         ComPtr<IHostName> hostName;
@@ -1144,6 +1147,7 @@ bool QNativeSocketEnginePrivate::fetchConnectionParameters()
             hr = info->get_RemotePort(tmpHString.GetAddressOf());
             Q_ASSERT_SUCCEEDED(hr);
             peerPort = qt_QStringFromHString(tmpHString).toInt();
+            inboundStreamCount = outboundStreamCount = 1;
         }
     }
     return true;
diff --git a/src/network/socket/qsocks5socketengine.cpp b/src/network/socket/qsocks5socketengine.cpp
index c873cbdedcf..0c15810a482 100644
--- a/src/network/socket/qsocks5socketengine.cpp
+++ b/src/network/socket/qsocks5socketengine.cpp
@@ -352,7 +352,7 @@ void QSocks5BindStore::add(qintptr socketDescriptor, QSocks5BindData *bindData)
 {
     QMutexLocker lock(&mutex);
     if (store.contains(socketDescriptor)) {
-        // qDebug() << "delete it";
+        // qDebug("delete it");
     }
     bindData->timeStamp.start();
     store.insert(socketDescriptor, bindData);
@@ -370,9 +370,11 @@ bool QSocks5BindStore::contains(qintptr socketDescriptor)
 QSocks5BindData *QSocks5BindStore::retrieve(qintptr socketDescriptor)
 {
     QMutexLocker lock(&mutex);
-    if (!store.contains(socketDescriptor))
+    const auto it = store.constFind(socketDescriptor);
+    if (it == store.cend())
         return 0;
-    QSocks5BindData *bindData = store.take(socketDescriptor);
+    QSocks5BindData *bindData = it.value();
+    store.erase(it);
     if (bindData) {
         if (bindData->controlSocket->thread() != QThread::currentThread()) {
             qWarning("Can not access socks5 bind data from different thread");
@@ -887,6 +889,7 @@ void QSocks5SocketEnginePrivate::parseRequestMethodReply()
         localPort = port;
 
         if (mode == ConnectMode) {
+            inboundStreamCount = outboundStreamCount = 1;
             socks5State = Connected;
             // notify the upper layer that we're done
             q->setState(QAbstractSocket::ConnectedState);
@@ -1047,6 +1050,7 @@ bool QSocks5SocketEngine::initialize(qintptr socketDescriptor, QAbstractSocket::
         d->localAddress = bindData->localAddress;
         d->peerPort = bindData->peerPort;
         d->peerAddress = bindData->peerAddress;
+        d->inboundStreamCount = d->outboundStreamCount = 1;
         delete bindData;
 
         QObject::connect(d->data->controlSocket, SIGNAL(connected()), this, SLOT(_q_controlSocketConnected()),
@@ -1187,7 +1191,7 @@ void QSocks5SocketEnginePrivate::_q_controlSocketReadNotification()
         case Connected: {
             QByteArray buf;
             if (!data->authenticator->unSeal(data->controlSocket, &buf)) {
-                // qDebug() << "unseal error maybe need to wait for more data";
+                // qDebug("unseal error maybe need to wait for more data");
             }
             if (buf.size()) {
                 QSOCKS5_DEBUG << dump(buf);
@@ -1486,6 +1490,7 @@ void QSocks5SocketEngine::close()
         }
         d->data->controlSocket->close();
     }
+    d->inboundStreamCount = d->outboundStreamCount = 0;
 #ifndef QT_NO_UDPSOCKET
     if (d->udpData && d->udpData->udpSocket)
         d->udpData->udpSocket->close();
diff --git a/src/network/ssl/qsslcertificate.cpp b/src/network/ssl/qsslcertificate.cpp
index b1ec1d06e20..96ba68089dc 100644
--- a/src/network/ssl/qsslcertificate.cpp
+++ b/src/network/ssl/qsslcertificate.cpp
@@ -482,8 +482,9 @@ QList<QSslCertificate> QSslCertificate::fromPath(const QString &path,
     if (pos != -1) {
         // there was a special char in the path so cut of the part containing that char.
         pathPrefix = pathPrefix.left(pos);
-        if (pathPrefix.contains(QLatin1Char('/')))
-            pathPrefix = pathPrefix.left(pathPrefix.lastIndexOf(QLatin1Char('/')));
+        const int lastIndexOfSlash = pathPrefix.lastIndexOf(QLatin1Char('/'));
+        if (lastIndexOfSlash != -1)
+            pathPrefix = pathPrefix.left(lastIndexOfSlash);
         else
             pathPrefix.clear();
     } else {
diff --git a/src/network/ssl/qsslsocket.cpp b/src/network/ssl/qsslsocket.cpp
index f1fbc304241..bbc62c47ff4 100644
--- a/src/network/ssl/qsslsocket.cpp
+++ b/src/network/ssl/qsslsocket.cpp
@@ -512,6 +512,8 @@ bool QSslSocket::setSocketDescriptor(qintptr socketDescriptor, SocketState state
     setPeerPort(d->plainSocket->peerPort());
     setPeerAddress(d->plainSocket->peerAddress());
     setPeerName(d->plainSocket->peerName());
+    d->readChannelCount = d->plainSocket->readChannelCount();
+    d->writeChannelCount = d->plainSocket->writeChannelCount();
     return retVal;
 }
 
@@ -1917,6 +1919,7 @@ void QSslSocket::connectToHost(const QString &hostName, quint16 port, OpenMode o
     d->plainSocket->setProxy(proxy());
 #endif
     QIODevice::open(openMode);
+    d->readChannelCount = d->writeChannelCount = 0;
     d->plainSocket->connectToHost(hostName, port, openMode, d->preferredNetworkLayerProtocol);
     d->cachedSocketDescriptor = d->plainSocket->socketDescriptor();
 }
@@ -2263,9 +2266,15 @@ void QSslSocketPrivate::createPlainSocket(QIODevice::OpenMode openMode)
     q->connect(plainSocket, SIGNAL(readyRead()),
                q, SLOT(_q_readyReadSlot()),
                Qt::DirectConnection);
+    q->connect(plainSocket, SIGNAL(channelReadyRead(int)),
+               q, SLOT(_q_channelReadyReadSlot(int)),
+               Qt::DirectConnection);
     q->connect(plainSocket, SIGNAL(bytesWritten(qint64)),
                q, SLOT(_q_bytesWrittenSlot(qint64)),
                Qt::DirectConnection);
+    q->connect(plainSocket, SIGNAL(channelBytesWritten(int, qint64)),
+               q, SLOT(_q_channelBytesWrittenSlot(int, qint64)),
+               Qt::DirectConnection);
 #ifndef QT_NO_NETWORKPROXY
     q->connect(plainSocket, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)),
                q, SIGNAL(proxyAuthenticationRequired(QNetworkProxy,QAuthenticator*)));
@@ -2319,6 +2328,7 @@ bool QSslSocketPrivate::bind(const QHostAddress &address, quint16 port, QAbstrac
     localPort = plainSocket->localPort();
     localAddress = plainSocket->localAddress();
     cachedSocketDescriptor = plainSocket->socketDescriptor();
+    readChannelCount = writeChannelCount = 0;
     return ret;
 }
 
@@ -2334,6 +2344,8 @@ void QSslSocketPrivate::_q_connectedSlot()
     q->setPeerAddress(plainSocket->peerAddress());
     q->setPeerName(plainSocket->peerName());
     cachedSocketDescriptor = plainSocket->socketDescriptor();
+    readChannelCount = plainSocket->readChannelCount();
+    writeChannelCount = plainSocket->writeChannelCount();
 
 #ifdef QSSLSOCKET_DEBUG
     qCDebug(lcSsl) << "QSslSocket::_q_connectedSlot()";
@@ -2436,6 +2448,16 @@ void QSslSocketPrivate::_q_readyReadSlot()
     transmit();
 }
 
+/*!
+    \internal
+*/
+void QSslSocketPrivate::_q_channelReadyReadSlot(int channel)
+{
+    Q_Q(QSslSocket);
+    if (mode == QSslSocket::UnencryptedMode)
+        emit q->channelReadyRead(channel);
+}
+
 /*!
     \internal
 */
@@ -2454,6 +2476,16 @@ void QSslSocketPrivate::_q_bytesWrittenSlot(qint64 written)
         q->disconnectFromHost();
 }
 
+/*!
+    \internal
+*/
+void QSslSocketPrivate::_q_channelBytesWrittenSlot(int channel, qint64 written)
+{
+    Q_Q(QSslSocket);
+    if (mode == QSslSocket::UnencryptedMode)
+        emit q->channelBytesWritten(channel, written);
+}
+
 /*!
     \internal
 */
diff --git a/src/network/ssl/qsslsocket.h b/src/network/ssl/qsslsocket.h
index dd4c8fec0be..1f2ed7687bb 100644
--- a/src/network/ssl/qsslsocket.h
+++ b/src/network/ssl/qsslsocket.h
@@ -220,7 +220,9 @@ private:
     Q_PRIVATE_SLOT(d_func(), void _q_stateChangedSlot(QAbstractSocket::SocketState))
     Q_PRIVATE_SLOT(d_func(), void _q_errorSlot(QAbstractSocket::SocketError))
     Q_PRIVATE_SLOT(d_func(), void _q_readyReadSlot())
+    Q_PRIVATE_SLOT(d_func(), void _q_channelReadyReadSlot(int))
     Q_PRIVATE_SLOT(d_func(), void _q_bytesWrittenSlot(qint64))
+    Q_PRIVATE_SLOT(d_func(), void _q_channelBytesWrittenSlot(int, qint64))
     Q_PRIVATE_SLOT(d_func(), void _q_flushWriteBuffer())
     Q_PRIVATE_SLOT(d_func(), void _q_flushReadBuffer())
     Q_PRIVATE_SLOT(d_func(), void _q_resumeImplementation())
diff --git a/src/network/ssl/qsslsocket_mac.cpp b/src/network/ssl/qsslsocket_mac.cpp
index e09a1973698..4122db4b65e 100644
--- a/src/network/ssl/qsslsocket_mac.cpp
+++ b/src/network/ssl/qsslsocket_mac.cpp
@@ -646,6 +646,7 @@ void QSslSocketBackendPrivate::transmit()
                 emit q->bytesWritten(totalBytesWritten);
                 emittedBytesWritten = false;
             }
+            emit q->channelBytesWritten(0, totalBytesWritten);
         }
     }
 
@@ -674,6 +675,7 @@ void QSslSocketBackendPrivate::transmit()
                 if (readyReadEmittedPointer)
                     *readyReadEmittedPointer = true;
                 emit q->readyRead();
+                emit q->channelReadyRead(0);
             }
 
             if (err == errSSLWouldBlock)
diff --git a/src/network/ssl/qsslsocket_openssl.cpp b/src/network/ssl/qsslsocket_openssl.cpp
index fea73edc63f..e164e1be61f 100644
--- a/src/network/ssl/qsslsocket_openssl.cpp
+++ b/src/network/ssl/qsslsocket_openssl.cpp
@@ -399,6 +399,10 @@ bool QSslSocketBackendPrivate::initSslContext()
         if (!ace.isEmpty()
             && !QHostAddress().setAddress(tlsHostName)
             && !(configuration.sslOptions & QSsl::SslOptionDisableServerNameIndication)) {
+            // We don't send the trailing dot from the host header if present see
+            // https://tools.ietf.org/html/rfc6066#section-3
+            if (ace.endsWith('.'))
+                ace.chop(1);
             if (!q_SSL_ctrl(ssl, SSL_CTRL_SET_TLSEXT_HOSTNAME, TLSEXT_NAMETYPE_host_name, ace.data()))
                 qCWarning(lcSsl, "could not set SSL_CTRL_SET_TLSEXT_HOSTNAME, Server Name Indication disabled");
         }
@@ -632,10 +636,12 @@ void QSslSocketPrivate::resetDefaultCiphers()
                 // Unconditionally exclude ADH and AECDH ciphers since they offer no MITM protection
                 if (!ciph.name().toLower().startsWith(QLatin1String("adh")) &&
                     !ciph.name().toLower().startsWith(QLatin1String("exp-adh")) &&
-                    !ciph.name().toLower().startsWith(QLatin1String("aecdh")))
+                    !ciph.name().toLower().startsWith(QLatin1String("aecdh"))) {
                     ciphers << ciph;
-                if (ciph.usedBits() >= 128)
-                    defaultCiphers << ciph;
+
+                    if (ciph.usedBits() >= 128)
+                        defaultCiphers << ciph;
+                }
             }
         }
     }
@@ -851,6 +857,7 @@ void QSslSocketBackendPrivate::transmit()
                     emit q->bytesWritten(totalBytesWritten);
                     emittedBytesWritten = false;
                 }
+                emit q->channelBytesWritten(0, totalBytesWritten);
             }
         }
 
@@ -954,6 +961,7 @@ void QSslSocketBackendPrivate::transmit()
                 if (readyReadEmittedPointer)
                     *readyReadEmittedPointer = true;
                 emit q->readyRead();
+                emit q->channelReadyRead(0);
                 transmitting = true;
                 continue;
             }
diff --git a/src/network/ssl/qsslsocket_p.h b/src/network/ssl/qsslsocket_p.h
index b96cf48d723..7f8dc375b62 100644
--- a/src/network/ssl/qsslsocket_p.h
+++ b/src/network/ssl/qsslsocket_p.h
@@ -179,7 +179,9 @@ public:
     void _q_stateChangedSlot(QAbstractSocket::SocketState);
     void _q_errorSlot(QAbstractSocket::SocketError);
     void _q_readyReadSlot();
+    void _q_channelReadyReadSlot(int);
     void _q_bytesWrittenSlot(qint64);
+    void _q_channelBytesWrittenSlot(int, qint64);
     void _q_flushWriteBuffer();
     void _q_flushReadBuffer();
     void _q_resumeImplementation();
diff --git a/src/network/ssl/qsslsocket_winrt.cpp b/src/network/ssl/qsslsocket_winrt.cpp
index dc5c9a8fac4..045c89eb0ea 100644
--- a/src/network/ssl/qsslsocket_winrt.cpp
+++ b/src/network/ssl/qsslsocket_winrt.cpp
@@ -306,6 +306,7 @@ void QSslSocketBackendPrivate::transmit()
                 emit q->bytesWritten(totalBytesWritten);
                 emittedBytesWritten = false;
             }
+            emit q->channelBytesWritten(0, totalBytesWritten);
         }
     }
 
@@ -323,6 +324,7 @@ void QSslSocketBackendPrivate::transmit()
         if (readyReadEmittedPointer)
             *readyReadEmittedPointer = true;
         emit q->readyRead();
+        emit q->channelReadyRead(0);
     }
 
     if (pendingClose) {
diff --git a/src/opengl/opengl.pro b/src/opengl/opengl.pro
index 9c62d41d3ea..007f73c45f3 100644
--- a/src/opengl/opengl.pro
+++ b/src/opengl/opengl.pro
@@ -8,8 +8,6 @@ irix-cc*:QMAKE_CXXFLAGS += -no_prelink -ptused
 
 QMAKE_DOCS = $$PWD/doc/qtopengl.qdocconf
 
-load(qt_module)
-
 contains(QT_CONFIG, opengl):CONFIG += opengl
 contains(QT_CONFIG, opengles2):CONFIG += opengles2
 
@@ -53,3 +51,5 @@ SOURCES +=  qglshaderprogram.cpp \
             gl2paintengineex/qpaintengineex_opengl2.cpp \
             gl2paintengineex/qglcustomshaderstage.cpp \
             gl2paintengineex/qtextureglyphcache_gl.cpp
+
+load(qt_module)
diff --git a/src/opengl/qglshaderprogram.cpp b/src/opengl/qglshaderprogram.cpp
index 77fc3e58f28..545df8fa44c 100644
--- a/src/opengl/qglshaderprogram.cpp
+++ b/src/opengl/qglshaderprogram.cpp
@@ -688,7 +688,7 @@ bool QGLShaderProgram::init()
     if (d->glfuncs->hasOpenGLFeature(QOpenGLFunctions::Shaders)) {
         GLuint program = d->glfuncs->glCreateProgram();
         if (!program) {
-            qWarning() << "QGLShaderProgram: could not create shader program";
+            qWarning("QGLShaderProgram: could not create shader program");
             return false;
         }
         if (d->programGuard)
@@ -696,7 +696,7 @@ bool QGLShaderProgram::init()
         d->programGuard = createSharedResourceGuard(context, program, freeProgramFunc);
         return true;
     } else {
-        qWarning() << "QGLShaderProgram: shader programs are not supported";
+        qWarning("QGLShaderProgram: shader programs are not supported");
         return false;
     }
 }
diff --git a/src/openglextensions/openglextensions.pro b/src/openglextensions/openglextensions.pro
index 948465165ef..18eec27e1c1 100644
--- a/src/openglextensions/openglextensions.pro
+++ b/src/openglextensions/openglextensions.pro
@@ -4,11 +4,11 @@ CONFIG += static
 contains(QT_CONFIG, opengl):CONFIG += opengl
 contains(QT_CONFIG, opengles2):CONFIG += opengles2
 
-load(qt_module)
-
 DEFINES += QT_NO_CAST_FROM_ASCII
 PRECOMPILED_HEADER =
 
 HEADERS = qopenglextensions.h
 
 SOURCES = qopenglextensions.cpp
+
+load(qt_module)
diff --git a/src/platformheaders/xcbfunctions/qxcbscreenfunctions.h b/src/platformheaders/xcbfunctions/qxcbscreenfunctions.h
new file mode 100644
index 00000000000..7773c275b9d
--- /dev/null
+++ b/src/platformheaders/xcbfunctions/qxcbscreenfunctions.h
@@ -0,0 +1,56 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QXCBSCREENFUNCTIONS_H
+#define QXCBSCREENFUNCTIONS_H
+
+#include <QtPlatformHeaders/QPlatformHeaderHelper>
+
+QT_BEGIN_NAMESPACE
+
+class QScreen;
+
+class QXcbScreenFunctions
+{
+public:
+    typedef bool (*VirtualDesktopNumber)(const QScreen *screen);
+    static const QByteArray virtualDesktopNumberIdentifier() { return QByteArrayLiteral("XcbVirtualDesktopNumber"); }
+    static int virtualDesktopNumber(const QScreen *screen)
+    {
+        return QPlatformHeaderHelper::callPlatformFunction<int, VirtualDesktopNumber, const QScreen *>(virtualDesktopNumberIdentifier(), screen);
+    }
+};
+
+QT_END_NAMESPACE
+
+#endif  /*QXCBSCREENFUNCTIONS_H*/
diff --git a/src/platformheaders/xcbfunctions/xcbfunctions.pri b/src/platformheaders/xcbfunctions/xcbfunctions.pri
index 7f611d80bd5..3f2bcb2b34c 100644
--- a/src/platformheaders/xcbfunctions/xcbfunctions.pri
+++ b/src/platformheaders/xcbfunctions/xcbfunctions.pri
@@ -1,3 +1,4 @@
 HEADERS += \
     $$PWD/qxcbwindowfunctions.h \
-    $$PWD/qxcbintegrationfunctions.h
+    $$PWD/qxcbintegrationfunctions.h \
+    $$PWD/qxcbscreenfunctions.h
diff --git a/src/platformsupport/cglconvenience/cglconvenience.mm b/src/platformsupport/cglconvenience/cglconvenience.mm
index aafd4db863b..a18510a9e27 100644
--- a/src/platformsupport/cglconvenience/cglconvenience.mm
+++ b/src/platformsupport/cglconvenience/cglconvenience.mm
@@ -42,19 +42,7 @@
 #include <QtCore/private/qcore_mac_p.h>
 #include <AppKit/AppKit.h>
 #include <QVector>
-
-void (*qcgl_getProcAddress(const QByteArray &procName))()
-{
-    CFURLRef url = CFURLCreateWithFileSystemPath(kCFAllocatorDefault,
-            CFSTR("/System/Library/Frameworks/OpenGL.framework"), kCFURLPOSIXPathStyle, false);
-    CFBundleRef bundle = CFBundleCreate(kCFAllocatorDefault, url);
-    CFStringRef procNameCF = QCFString::toCFStringRef(QString::fromLatin1(procName.constData()));
-    void *proc = CFBundleGetFunctionPointerForName(bundle, procNameCF);
-    CFRelease(url);
-    CFRelease(bundle);
-    CFRelease(procNameCF);
-    return (void (*) ())proc;
-}
+#include <qdebug.h>
 
 // Match up with createNSOpenGLPixelFormat below!
 QSurfaceFormat qcgl_surfaceFormat()
diff --git a/src/platformsupport/cglconvenience/cglconvenience_p.h b/src/platformsupport/cglconvenience/cglconvenience_p.h
index cb0820263a6..e531e73549d 100644
--- a/src/platformsupport/cglconvenience/cglconvenience_p.h
+++ b/src/platformsupport/cglconvenience/cglconvenience_p.h
@@ -55,7 +55,6 @@
 #include <QString>
 #include <OpenGL/OpenGL.h>
 
-void (*qcgl_getProcAddress(const QByteArray &procName))();
 QSurfaceFormat qcgl_surfaceFormat();
 void *qcgl_createNSOpenGLPixelFormat(const QSurfaceFormat &format);
 
diff --git a/src/platformsupport/clipboard/qmacmime.mm b/src/platformsupport/clipboard/qmacmime.mm
index 8a750b8dcb9..2ad734b8b9e 100644
--- a/src/platformsupport/clipboard/qmacmime.mm
+++ b/src/platformsupport/clipboard/qmacmime.mm
@@ -643,7 +643,7 @@ QList<QByteArray> QMacPasteboardMimeFileUri::convertFromMime(const QString &mime
         QUrl url = urls.at(i).toUrl();
         if (url.scheme().isEmpty())
             url.setScheme(QLatin1String("file"));
-        if (url.scheme().toLower() == QLatin1String("file")) {
+        if (url.scheme() == QLatin1String("file")) {
             if (url.host().isEmpty())
                 url.setHost(QLatin1String("localhost"));
             url.setPath(url.path().normalized(QString::NormalizationForm_D));
@@ -722,7 +722,7 @@ QList<QByteArray> QMacPasteboardMimeUrl::convertFromMime(const QString &mime, QV
         QUrl url = urls.at(i).toUrl();
         if (url.scheme().isEmpty())
             url.setScheme(QLatin1String("file"));
-        if (url.scheme().toLower() == QLatin1String("file")) {
+        if (url.scheme() == QLatin1String("file")) {
             if (url.host().isEmpty())
                 url.setHost(QLatin1String("localhost"));
             url.setPath(url.path().normalized(QString::NormalizationForm_D));
diff --git a/src/platformsupport/dbusmenu/qdbusmenubar.cpp b/src/platformsupport/dbusmenu/qdbusmenubar.cpp
index 7d53de6db43..76d658f51a1 100644
--- a/src/platformsupport/dbusmenu/qdbusmenubar.cpp
+++ b/src/platformsupport/dbusmenu/qdbusmenubar.cpp
@@ -133,6 +133,11 @@ QPlatformMenu *QDBusMenuBar::menuForTag(quintptr tag) const
     return nullptr;
 }
 
+QPlatformMenu *QDBusMenuBar::createMenu() const
+{
+    return new QDBusPlatformMenu;
+}
+
 void QDBusMenuBar::registerMenuBar()
 {
     static uint menuBarId = 0;
diff --git a/src/platformsupport/dbusmenu/qdbusmenubar_p.h b/src/platformsupport/dbusmenu/qdbusmenubar_p.h
index 157befe9e3e..8266a395f5a 100644
--- a/src/platformsupport/dbusmenu/qdbusmenubar_p.h
+++ b/src/platformsupport/dbusmenu/qdbusmenubar_p.h
@@ -72,6 +72,7 @@ public:
     void syncMenu(QPlatformMenu *menu) Q_DECL_OVERRIDE;
     void handleReparent(QWindow *newParentWindow) Q_DECL_OVERRIDE;
     QPlatformMenu *menuForTag(quintptr tag) const Q_DECL_OVERRIDE;
+    QPlatformMenu *createMenu() const Q_DECL_OVERRIDE;
 
 private:
     QDBusPlatformMenu *m_menu;
diff --git a/src/platformsupport/eglconvenience/eglconvenience.pri b/src/platformsupport/eglconvenience/eglconvenience.pri
index f1e0d58a6d2..fe6d0eb7484 100644
--- a/src/platformsupport/eglconvenience/eglconvenience.pri
+++ b/src/platformsupport/eglconvenience/eglconvenience.pri
@@ -26,4 +26,6 @@ contains(QT_CONFIG,egl) {
         LIBS_PRIVATE += $$QMAKE_LIBS_X11
     }
     CONFIG += egl
+
+    LIBS_PRIVATE += $$QMAKE_LIBS_DYNLOAD
 }
diff --git a/src/platformsupport/eglconvenience/qeglplatformcontext.cpp b/src/platformsupport/eglconvenience/qeglplatformcontext.cpp
index 9e7298b89ac..bd7254b73a5 100644
--- a/src/platformsupport/eglconvenience/qeglplatformcontext.cpp
+++ b/src/platformsupport/eglconvenience/qeglplatformcontext.cpp
@@ -48,6 +48,9 @@
 #ifdef Q_OS_ANDROID
 #include <QtCore/private/qjnihelpers_p.h>
 #endif
+#ifndef Q_OS_WIN
+#include <dlfcn.h>
+#endif
 
 QT_BEGIN_NAMESPACE
 
@@ -440,10 +443,15 @@ void QEGLPlatformContext::swapBuffers(QPlatformSurface *surface)
     }
 }
 
-void (*QEGLPlatformContext::getProcAddress(const QByteArray &procName)) ()
+QFunctionPointer QEGLPlatformContext::getProcAddress(const char *procName)
 {
     eglBindAPI(m_api);
-    return eglGetProcAddress(procName.constData());
+    QFunctionPointer proc = (QFunctionPointer) eglGetProcAddress(procName);
+#ifndef Q_OS_WIN
+    if (!proc)
+        proc = (QFunctionPointer) dlsym(RTLD_DEFAULT, procName);
+#endif
+    return proc;
 }
 
 QSurfaceFormat QEGLPlatformContext::format() const
diff --git a/src/platformsupport/eglconvenience/qeglplatformcontext_p.h b/src/platformsupport/eglconvenience/qeglplatformcontext_p.h
index 2679c3b9f89..e772f5df89b 100644
--- a/src/platformsupport/eglconvenience/qeglplatformcontext_p.h
+++ b/src/platformsupport/eglconvenience/qeglplatformcontext_p.h
@@ -76,7 +76,7 @@ public:
     bool makeCurrent(QPlatformSurface *surface) Q_DECL_OVERRIDE;
     void doneCurrent() Q_DECL_OVERRIDE;
     void swapBuffers(QPlatformSurface *surface) Q_DECL_OVERRIDE;
-    QFunctionPointer getProcAddress(const QByteArray &procName) Q_DECL_OVERRIDE;
+    QFunctionPointer getProcAddress(const char *procName) Q_DECL_OVERRIDE;
 
     QSurfaceFormat format() const Q_DECL_OVERRIDE;
     bool isSharing() const Q_DECL_OVERRIDE { return m_shareContext != EGL_NO_CONTEXT; }
diff --git a/src/platformsupport/fontdatabases/fontconfig/qfontconfigdatabase.cpp b/src/platformsupport/fontdatabases/fontconfig/qfontconfigdatabase.cpp
index 5ca07497873..b288a05e32c 100644
--- a/src/platformsupport/fontdatabases/fontconfig/qfontconfigdatabase.cpp
+++ b/src/platformsupport/fontdatabases/fontconfig/qfontconfigdatabase.cpp
@@ -868,7 +868,7 @@ void QFontconfigDatabase::setupFontEngine(QFontEngineFT *engine, const QFontDef
 
     const QPlatformServices *services = QGuiApplicationPrivate::platformIntegration()->services();
     bool useXftConf = (services && (services->desktopEnvironment() == "GNOME" || services->desktopEnvironment() == "UNITY"));
-    if (useXftConf) {
+    if (useXftConf && !forcedAntialiasSetting) {
         void *antialiasResource =
                 QGuiApplication::platformNativeInterface()->nativeResourceForScreen("antialiasingEnabled",
                                                                                     QGuiApplication::primaryScreen());
diff --git a/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase.mm b/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase.mm
index 9dba1ca1f17..f5372151b79 100644
--- a/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase.mm
+++ b/src/platformsupport/fontdatabases/mac/qcoretextfontdatabase.mm
@@ -524,9 +524,6 @@ QStringList QCoreTextFontDatabase::fallbacksForFamily(const QString &family, QFo
         if (&CTFontCopyDefaultCascadeListForLanguages)
   #endif
         {
-            if (fallbackLists.contains(family))
-                return fallbackLists.value(family);
-
             QCFType<CFMutableDictionaryRef> attributes = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
             CFDictionaryAddValue(attributes, kCTFontFamilyNameAttribute, QCFString(family));
             if (QCFType<CTFontDescriptorRef> fontDescriptor = CTFontDescriptorCreateWithAttributes(attributes)) {
@@ -554,12 +551,9 @@ QStringList QCoreTextFontDatabase::fallbacksForFamily(const QString &family, QFo
                             fallbackList.append(QStringLiteral("Arial Unicode MS"));
 #endif
 
-                        fallbackLists[family] = fallbackList;
+                        return fallbackList;
                     }
                 }
-
-                if (fallbackLists.contains(family))
-                    return fallbackLists.value(family);
             }
         }
 #endif
@@ -1003,7 +997,7 @@ QFontEngine *QCoreTextFontDatabase::freeTypeFontEngine(const QFontDef &fontDef,
     }
 
     if (!engine->init(faceId, antialias, format, fontData) || engine->invalid()) {
-        qWarning() << "QCoreTextFontDatabase::freeTypefontEngine Failed to create engine";
+        qWarning("QCoreTextFontDatabase::freeTypefontEngine Failed to create engine");
         return Q_NULLPTR;
     }
     engine->setQtDefaultHintStyle(static_cast<QFont::HintingPreference>(fontDef.hintingPreference));
diff --git a/src/platformsupport/input/evdevtouch/qevdevtouchhandler.cpp b/src/platformsupport/input/evdevtouch/qevdevtouchhandler.cpp
index cec596ebb2d..6b98ed30a90 100644
--- a/src/platformsupport/input/evdevtouch/qevdevtouchhandler.cpp
+++ b/src/platformsupport/input/evdevtouch/qevdevtouchhandler.cpp
@@ -538,9 +538,16 @@ void QEvdevTouchScreenData::processInputEvent(input_event *data)
             it.next();
             Contact &contact(it.value());
             int key = m_typeB ? it.key() : contact.trackingId;
-            if (!m_contacts.contains(key)) {
-                contact.state = Qt::TouchPointReleased;
-                addTouchPoint(contact, &combinedStates);
+            if (m_typeB) {
+                if (contact.trackingId != m_contacts[key].trackingId && contact.state) {
+                    contact.state = Qt::TouchPointReleased;
+                    addTouchPoint(contact, &combinedStates);
+                }
+            } else {
+                if (!m_contacts.contains(key)) {
+                    contact.state = Qt::TouchPointReleased;
+                    addTouchPoint(contact, &combinedStates);
+                }
             }
         }
 
diff --git a/src/platformsupport/linuxaccessibility/atspiadaptor.cpp b/src/platformsupport/linuxaccessibility/atspiadaptor.cpp
index d982c5afff8..2b81de43a74 100644
--- a/src/platformsupport/linuxaccessibility/atspiadaptor.cpp
+++ b/src/platformsupport/linuxaccessibility/atspiadaptor.cpp
@@ -783,7 +783,7 @@ void AtSpiAdaptor::updateEventListeners()
         }
         m_applicationAdaptor->sendEvents(!evList.isEmpty());
     } else {
-        qAtspiDebug() << "Could not query active accessibility event listeners.";
+        qAtspiDebug("Could not query active accessibility event listeners.");
     }
 }
 
@@ -944,7 +944,7 @@ void AtSpiAdaptor::notify(QAccessibleEvent *event)
         if (sendObject || sendObject_text_changed) {
             QAccessibleInterface * iface = event->accessibleInterface();
             if (!iface || !iface->textInterface()) {
-                qAtspiDebug() << "Received text event for invalid interface.";
+                qAtspiDebug("Received text event for invalid interface.");
                 return;
             }
             QString path = pathForInterface(iface);
@@ -1030,7 +1030,7 @@ void AtSpiAdaptor::notify(QAccessibleEvent *event)
         if (sendObject || sendObject_value_changed || sendObject_property_change_accessible_value) {
             QAccessibleInterface * iface = event->accessibleInterface();
             if (!iface) {
-                qWarning() << "ValueChanged event from invalid accessible.";
+                qWarning("ValueChanged event from invalid accessible.");
                 return;
             }
             if (iface->valueInterface()) {
@@ -1059,7 +1059,7 @@ void AtSpiAdaptor::notify(QAccessibleEvent *event)
     case QAccessible::Selection: {
         QAccessibleInterface * iface = event->accessibleInterface();
         if (!iface) {
-            qWarning() << "Selection event from invalid accessible.";
+            qWarning("Selection event from invalid accessible.");
             return;
         }
         QString path = pathForInterface(iface);
@@ -1076,7 +1076,7 @@ void AtSpiAdaptor::notify(QAccessibleEvent *event)
             if (stateChange.checked) {
                 QAccessibleInterface * iface = event->accessibleInterface();
                 if (!iface) {
-                    qWarning() << "StateChanged event from invalid accessible.";
+                    qWarning("StateChanged event from invalid accessible.");
                     return;
                 }
                 int checked = iface->state().checked;
@@ -1481,7 +1481,7 @@ QStringList AtSpiAdaptor::accessibleInterfaces(QAccessibleInterface *interface)
         }
 #ifdef ACCESSIBLE_CREATION_DEBUG
     else {
-        qAtspiDebug() << " IS NOT a component";
+        qAtspiDebug(" IS NOT a component");
     }
 #endif
     if (interface->role() == QAccessible::Application)
@@ -1538,7 +1538,7 @@ QString AtSpiAdaptor::pathForObject(QObject *object) const
     Q_ASSERT(object);
 
     if (inheritsQAction(object)) {
-        qAtspiDebug() << "AtSpiAdaptor::pathForObject: warning: creating path with QAction as object.";
+        qAtspiDebug("AtSpiAdaptor::pathForObject: warning: creating path with QAction as object.");
     }
 
     QAccessibleInterface *iface = QAccessible::queryAccessibleInterface(object);
@@ -1669,18 +1669,18 @@ bool AtSpiAdaptor::componentInterface(QAccessibleInterface *interface, const QSt
 //        int width = message.arguments().at(2).toInt();
 //        int height = message.arguments().at(3).toInt();
 //        uint coordinateType = message.arguments().at(4).toUInt();
-        qAtspiDebug() << "SetExtents is not implemented.";
+        qAtspiDebug("SetExtents is not implemented.");
         sendReply(connection, message, false);
     } else if (function == QLatin1String("SetPosition")) {
 //        int x = message.arguments().at(0).toInt();
 //        int y = message.arguments().at(1).toInt();
 //        uint coordinateType = message.arguments().at(2).toUInt();
-        qAtspiDebug() << "SetPosition is not implemented.";
+        qAtspiDebug("SetPosition is not implemented.");
         sendReply(connection, message, false);
     } else if (function == QLatin1String("SetSize")) {
 //        int width = message.arguments().at(0).toInt();
 //        int height = message.arguments().at(1).toInt();
-        qAtspiDebug() << "SetSize is not implemented.";
+        qAtspiDebug("SetSize is not implemented.");
         sendReply(connection, message, false);
     } else {
         qAtspiDebug() << "WARNING: AtSpiAdaptor::componentInterface does not implement " << function << message.path();
diff --git a/src/platformsupport/themes/genericunix/qgenericunixthemes.cpp b/src/platformsupport/themes/genericunix/qgenericunixthemes.cpp
index aee12eed76f..720b032ea52 100644
--- a/src/platformsupport/themes/genericunix/qgenericunixthemes.cpp
+++ b/src/platformsupport/themes/genericunix/qgenericunixthemes.cpp
@@ -191,13 +191,6 @@ QStringList QGenericUnixTheme::xdgIconThemePaths()
 }
 
 #ifndef QT_NO_DBUS
-QPlatformMenu *QGenericUnixTheme::createPlatformMenu() const
-{
-    if (isDBusGlobalMenuAvailable())
-        return new QDBusPlatformMenu();
-    return nullptr;
-}
-
 QPlatformMenuBar *QGenericUnixTheme::createPlatformMenuBar() const
 {
     if (isDBusGlobalMenuAvailable())
@@ -594,13 +587,6 @@ QPlatformTheme *QKdeTheme::createKdeTheme()
 }
 
 #ifndef QT_NO_DBUS
-QPlatformMenu *QKdeTheme::createPlatformMenu() const
-{
-    if (isDBusGlobalMenuAvailable())
-        return new QDBusPlatformMenu();
-    return nullptr;
-}
-
 QPlatformMenuBar *QKdeTheme::createPlatformMenuBar() const
 {
     if (isDBusGlobalMenuAvailable())
@@ -706,13 +692,6 @@ QString QGnomeTheme::gtkFontName() const
 }
 
 #ifndef QT_NO_DBUS
-QPlatformMenu *QGnomeTheme::createPlatformMenu() const
-{
-    if (isDBusGlobalMenuAvailable())
-        return new QDBusPlatformMenu();
-    return nullptr;
-}
-
 QPlatformMenuBar *QGnomeTheme::createPlatformMenuBar() const
 {
     if (isDBusGlobalMenuAvailable())
diff --git a/src/platformsupport/themes/genericunix/qgenericunixthemes_p.h b/src/platformsupport/themes/genericunix/qgenericunixthemes_p.h
index b7e0d53d6f0..952658e130b 100644
--- a/src/platformsupport/themes/genericunix/qgenericunixthemes_p.h
+++ b/src/platformsupport/themes/genericunix/qgenericunixthemes_p.h
@@ -86,7 +86,6 @@ public:
 
     static QStringList xdgIconThemePaths();
 #ifndef QT_NO_DBUS
-    QPlatformMenu *createPlatformMenu() const Q_DECL_OVERRIDE;
     QPlatformMenuBar *createPlatformMenuBar() const Q_DECL_OVERRIDE;
 #endif
 #if !defined(QT_NO_DBUS) && !defined(QT_NO_SYSTEMTRAYICON)
@@ -112,7 +111,6 @@ public:
 
     const QFont *font(Font type) const Q_DECL_OVERRIDE;
 #ifndef QT_NO_DBUS
-    QPlatformMenu *createPlatformMenu() const Q_DECL_OVERRIDE;
     QPlatformMenuBar *createPlatformMenuBar() const Q_DECL_OVERRIDE;
 #endif
 #if !defined(QT_NO_DBUS) && !defined(QT_NO_SYSTEMTRAYICON)
@@ -136,7 +134,6 @@ public:
 
     virtual QString gtkFontName() const;
 #ifndef QT_NO_DBUS
-    QPlatformMenu *createPlatformMenu() const Q_DECL_OVERRIDE;
     QPlatformMenuBar *createPlatformMenuBar() const Q_DECL_OVERRIDE;
 #endif
 #if !defined(QT_NO_DBUS) && !defined(QT_NO_SYSTEMTRAYICON)
diff --git a/src/plugins/bearer/android/src/src.pro b/src/plugins/bearer/android/src/src.pro
index 1050601896e..eb0738386c6 100644
--- a/src/plugins/bearer/android/src/src.pro
+++ b/src/plugins/bearer/android/src/src.pro
@@ -1,11 +1,5 @@
-include(wrappers/wrappers.pri)
-
 TARGET = qandroidbearer
 
-PLUGIN_TYPE = bearer
-PLUGIN_CLASS_NAME = QAndroidBearerEnginePlugin
-load(qt_plugin)
-
 QT = core-private network-private
 
 HEADERS += qandroidbearerengine.h \
@@ -15,3 +9,9 @@ HEADERS += qandroidbearerengine.h \
 SOURCES += main.cpp \
            qandroidbearerengine.cpp \
            ../../qnetworksession_impl.cpp
+
+include(wrappers/wrappers.pri)
+
+PLUGIN_TYPE = bearer
+PLUGIN_CLASS_NAME = QAndroidBearerEnginePlugin
+load(qt_plugin)
diff --git a/src/plugins/bearer/connman/connman.pro b/src/plugins/bearer/connman/connman.pro
index efa13a6ebdc..9f3fff304bd 100644
--- a/src/plugins/bearer/connman/connman.pro
+++ b/src/plugins/bearer/connman/connman.pro
@@ -1,9 +1,5 @@
 TARGET = qconnmanbearer
 
-PLUGIN_TYPE = bearer
-PLUGIN_CLASS_NAME = QConnmanEnginePlugin
-load(qt_plugin)
-
 QT = core network-private dbus
 CONFIG += link_pkgconfig
 
@@ -21,3 +17,6 @@ SOURCES += main.cpp \
 
 OTHER_FILES += connman.json
 
+PLUGIN_TYPE = bearer
+PLUGIN_CLASS_NAME = QConnmanEnginePlugin
+load(qt_plugin)
diff --git a/src/plugins/bearer/connman/qconnmanservice_linux.cpp b/src/plugins/bearer/connman/qconnmanservice_linux.cpp
index 901af8dece2..135aad4dec9 100644
--- a/src/plugins/bearer/connman/qconnmanservice_linux.cpp
+++ b/src/plugins/bearer/connman/qconnmanservice_linux.cpp
@@ -162,7 +162,7 @@ void QConnmanManagerInterface::connectNotify(const QMetaMethod &signal)
                                QLatin1String(CONNMAN_MANAGER_INTERFACE),
                                QLatin1String("PropertyChanged"),
                                    this,SIGNAL(propertyChanged(QString,QDBusVariant)))) {
-            qWarning() << "PropertyChanged not connected";
+            qWarning("PropertyChanged not connected");
         }
     }
 
@@ -173,7 +173,7 @@ void QConnmanManagerInterface::connectNotify(const QMetaMethod &signal)
                                QLatin1String(CONNMAN_MANAGER_INTERFACE),
                                QLatin1String("ServicesChanged"),
                                this,SLOT(onServicesChanged(ConnmanMapList, QList<QDBusObjectPath>)))) {
-            qWarning() << "servicesChanged not connected";
+            qWarning("servicesChanged not connected");
         }
     }
 }
diff --git a/src/plugins/bearer/corewlan/corewlan.pro b/src/plugins/bearer/corewlan/corewlan.pro
index 674af0cbbe7..ab0257aecda 100644
--- a/src/plugins/bearer/corewlan/corewlan.pro
+++ b/src/plugins/bearer/corewlan/corewlan.pro
@@ -1,9 +1,5 @@
 TARGET = qcorewlanbearer
 
-PLUGIN_TYPE = bearer
-PLUGIN_CLASS_NAME = QCoreWlanEnginePlugin
-load(qt_plugin)
-
 QT = core-private network-private
 LIBS += -framework Foundation -framework SystemConfiguration
 
@@ -21,3 +17,7 @@ SOURCES += main.cpp \
 OBJECTIVE_SOURCES += qcorewlanengine.mm
 
 OTHER_FILES += corewlan.json
+
+PLUGIN_TYPE = bearer
+PLUGIN_CLASS_NAME = QCoreWlanEnginePlugin
+load(qt_plugin)
diff --git a/src/plugins/bearer/corewlan/qcorewlanengine.mm b/src/plugins/bearer/corewlan/qcorewlanengine.mm
index aab8a5e05bb..3f8f80fc857 100644
--- a/src/plugins/bearer/corewlan/qcorewlanengine.mm
+++ b/src/plugins/bearer/corewlan/qcorewlanengine.mm
@@ -164,6 +164,7 @@ void QScanThread::run()
     mutex.lock();
     CWInterface *currentInterface = [CWInterface interfaceWithName: QCFString::toNSString(interfaceName)];
     mutex.unlock();
+    const bool currentInterfaceServiceActive = currentInterface.serviceActive;
 
     if (currentInterface.powerOn) {
         NSError *err = nil;
@@ -178,7 +179,7 @@ void QScanThread::run()
 
                 QNetworkConfiguration::StateFlags state = QNetworkConfiguration::Undefined;
                 bool known = isKnownSsid(networkSsid);
-                if (currentInterface.serviceActive) {
+                if (currentInterfaceServiceActive) {
                     if( networkSsid == QCFString::toQString( [currentInterface ssid])) {
                         state = QNetworkConfiguration::Active;
                     }
@@ -221,7 +222,7 @@ void QScanThread::run()
                 interfaceName = ij.value();
             }
 
-            if (currentInterface.serviceActive) {
+            if (currentInterfaceServiceActive) {
                 if( networkSsid == QCFString::toQString([currentInterface ssid])) {
                     state = QNetworkConfiguration::Active;
                 }
diff --git a/src/plugins/bearer/generic/generic.pro b/src/plugins/bearer/generic/generic.pro
index d0e17380e3f..f71a9013415 100644
--- a/src/plugins/bearer/generic/generic.pro
+++ b/src/plugins/bearer/generic/generic.pro
@@ -1,9 +1,5 @@
 TARGET = qgenericbearer
 
-PLUGIN_TYPE = bearer
-PLUGIN_CLASS_NAME = QGenericEnginePlugin
-load(qt_plugin)
-
 QT = core-private network-private
 
 HEADERS += qgenericengine.h \
@@ -15,3 +11,7 @@ SOURCES += qgenericengine.cpp \
            main.cpp
 
 OTHER_FILES += generic.json
+
+PLUGIN_TYPE = bearer
+PLUGIN_CLASS_NAME = QGenericEnginePlugin
+load(qt_plugin)
diff --git a/src/plugins/bearer/nativewifi/nativewifi.pro b/src/plugins/bearer/nativewifi/nativewifi.pro
index e372c8ca05c..da7f2da353e 100644
--- a/src/plugins/bearer/nativewifi/nativewifi.pro
+++ b/src/plugins/bearer/nativewifi/nativewifi.pro
@@ -1,9 +1,5 @@
 TARGET = qnativewifibearer
 
-PLUGIN_TYPE = bearer
-PLUGIN_CLASS_NAME = QNativeWifiEnginePlugin
-load(qt_plugin)
-
 QT = core-private network-private
 
 HEADERS += qnativewifiengine.h \
@@ -16,3 +12,7 @@ SOURCES += main.cpp \
            ../qnetworksession_impl.cpp
 
 OTHER_FILES += nativewifi.json
+
+PLUGIN_TYPE = bearer
+PLUGIN_CLASS_NAME = QNativeWifiEnginePlugin
+load(qt_plugin)
diff --git a/src/plugins/bearer/networkmanager/networkmanager.pro b/src/plugins/bearer/networkmanager/networkmanager.pro
index b3a270615cc..e71c93f66f0 100644
--- a/src/plugins/bearer/networkmanager/networkmanager.pro
+++ b/src/plugins/bearer/networkmanager/networkmanager.pro
@@ -1,9 +1,5 @@
 TARGET = qnmbearer
 
-PLUGIN_TYPE = bearer
-PLUGIN_CLASS_NAME = QNetworkManagerEnginePlugin
-load(qt_plugin)
-
 QT = core network-private dbus
 
 HEADERS += qnetworkmanagerservice.h \
@@ -19,3 +15,7 @@ SOURCES += main.cpp \
            ../qnetworksession_impl.cpp
 
 OTHER_FILES += networkmanager.json
+
+PLUGIN_TYPE = bearer
+PLUGIN_CLASS_NAME = QNetworkManagerEnginePlugin
+load(qt_plugin)
diff --git a/src/plugins/bearer/networkmanager/qnetworkmanagerservice.cpp b/src/plugins/bearer/networkmanager/qnetworkmanagerservice.cpp
index 8eebf86d670..6c3c661db6f 100644
--- a/src/plugins/bearer/networkmanager/qnetworkmanagerservice.cpp
+++ b/src/plugins/bearer/networkmanager/qnetworkmanagerservice.cpp
@@ -136,7 +136,7 @@ bool QNetworkManagerInterface::setConnections()
 QList <QDBusObjectPath> QNetworkManagerInterface::getDevices()
 {
     if (devicesPathList.isEmpty()) {
-        //qWarning() << "using blocking call!";
+        //qWarning("using blocking call!");
         QDBusReply<QList<QDBusObjectPath> > reply = call(QLatin1String("GetDevices"));
         devicesPathList = reply.value();
     }
@@ -639,7 +639,7 @@ void QNetworkManagerInterfaceDeviceWireless::accessPointsFinished(QDBusPendingCa
 QList <QDBusObjectPath> QNetworkManagerInterfaceDeviceWireless::getAccessPoints()
 {
     if (accessPointsList.isEmpty()) {
-        //qWarning() << "Using blocking call!";
+        //qWarning("Using blocking call!");
         QDBusReply<QList<QDBusObjectPath> > reply
                 = call(QLatin1String("GetAccessPoints"));
         accessPointsList = reply.value();
@@ -802,7 +802,7 @@ bool QNetworkManagerSettings::setConnections()
 QList <QDBusObjectPath> QNetworkManagerSettings::listConnections()
 {
     if (connectionsList.isEmpty()) {
-        //qWarning() << "Using blocking call!";
+        //qWarning("Using blocking call!");
         QDBusReply<QList<QDBusObjectPath> > reply
                 = call(QLatin1String("ListConnections"));
         connectionsList = reply.value();
@@ -874,7 +874,7 @@ void QNetworkManagerSettingsConnection::slotSettingsRemoved()
 QNmSettingsMap QNetworkManagerSettingsConnection::getSettings()
 {
     if (settingsMap.isEmpty()) {
-        //qWarning() << "Using blocking call!";
+        //qWarning("Using blocking call!");
         QDBusReply<QNmSettingsMap> reply = call(QLatin1String("GetSettings"));
         settingsMap = reply.value();
     }
diff --git a/src/plugins/bearer/nla/nla.pro b/src/plugins/bearer/nla/nla.pro
index bac76084779..32ff5446e51 100644
--- a/src/plugins/bearer/nla/nla.pro
+++ b/src/plugins/bearer/nla/nla.pro
@@ -1,9 +1,5 @@
 TARGET = qnlabearer
 
-PLUGIN_TYPE = bearer
-PLUGIN_CLASS_NAME = QNlaEnginePlugin
-load(qt_plugin)
-
 QT = core core-private network network-private
 
 !wince* {
@@ -22,3 +18,7 @@ SOURCES += main.cpp \
            ../qnetworksession_impl.cpp
 
 OTHER_FILES += nla.json
+
+PLUGIN_TYPE = bearer
+PLUGIN_CLASS_NAME = QNlaEnginePlugin
+load(qt_plugin)
diff --git a/src/plugins/bearer/nla/qnlaengine.cpp b/src/plugins/bearer/nla/qnlaengine.cpp
index 0b765a84852..726e1efb92b 100644
--- a/src/plugins/bearer/nla/qnlaengine.cpp
+++ b/src/plugins/bearer/nla/qnlaengine.cpp
@@ -110,10 +110,10 @@ static void printBlob(NLA_BLOB *blob)
                  << "\tshared adapter name:" << blob->data.ICS.remote.sharedAdapterName;
         break;
     default:
-        qDebug() << "UNKNOWN BLOB TYPE";
+        qDebug("UNKNOWN BLOB TYPE");
     }
 
-    qDebug() << "===== END NLA_BLOB =====";
+    qDebug("===== END NLA_BLOB =====");
 }
 #endif
 
diff --git a/src/plugins/generic/evdevkeyboard/evdevkeyboard.pro b/src/plugins/generic/evdevkeyboard/evdevkeyboard.pro
index 101ea30bcca..d23ad3bad08 100644
--- a/src/plugins/generic/evdevkeyboard/evdevkeyboard.pro
+++ b/src/plugins/generic/evdevkeyboard/evdevkeyboard.pro
@@ -1,10 +1,5 @@
 TARGET = qevdevkeyboardplugin
 
-PLUGIN_TYPE = generic
-PLUGIN_EXTENDS = -
-PLUGIN_CLASS_NAME = QEvdevKeyboardPlugin
-load(qt_plugin)
-
 QT += core-private platformsupport-private gui-private
 
 SOURCES = main.cpp
@@ -12,3 +7,7 @@ SOURCES = main.cpp
 OTHER_FILES += \
     evdevkeyboard.json
 
+PLUGIN_TYPE = generic
+PLUGIN_EXTENDS = -
+PLUGIN_CLASS_NAME = QEvdevKeyboardPlugin
+load(qt_plugin)
diff --git a/src/plugins/generic/evdevmouse/evdevmouse.pro b/src/plugins/generic/evdevmouse/evdevmouse.pro
index 57a67ead8da..1a0bc088537 100644
--- a/src/plugins/generic/evdevmouse/evdevmouse.pro
+++ b/src/plugins/generic/evdevmouse/evdevmouse.pro
@@ -1,10 +1,5 @@
 TARGET = qevdevmouseplugin
 
-PLUGIN_TYPE = generic
-PLUGIN_EXTENDS = -
-PLUGIN_CLASS_NAME = QEvdevMousePlugin
-load(qt_plugin)
-
 QT += core-private platformsupport-private gui-private
 
 SOURCES = main.cpp
@@ -12,3 +7,7 @@ SOURCES = main.cpp
 OTHER_FILES += \
     evdevmouse.json
 
+PLUGIN_TYPE = generic
+PLUGIN_EXTENDS = -
+PLUGIN_CLASS_NAME = QEvdevMousePlugin
+load(qt_plugin)
diff --git a/src/plugins/generic/evdevtablet/evdevtablet.pro b/src/plugins/generic/evdevtablet/evdevtablet.pro
index 8ffc0db84d5..aaf0ef4c678 100644
--- a/src/plugins/generic/evdevtablet/evdevtablet.pro
+++ b/src/plugins/generic/evdevtablet/evdevtablet.pro
@@ -1,13 +1,13 @@
 TARGET = qevdevtabletplugin
 
-PLUGIN_TYPE = generic
-PLUGIN_EXTENDS = -
-PLUGIN_CLASS_NAME = QEvdevTabletPlugin
-load(qt_plugin)
-
 SOURCES = main.cpp
 
 QT += core-private platformsupport-private gui-private
 
 OTHER_FILES += \
     evdevtablet.json
+
+PLUGIN_TYPE = generic
+PLUGIN_EXTENDS = -
+PLUGIN_CLASS_NAME = QEvdevTabletPlugin
+load(qt_plugin)
diff --git a/src/plugins/generic/evdevtouch/evdevtouch.pro b/src/plugins/generic/evdevtouch/evdevtouch.pro
index 1f4d1b7e935..4d61db4eb05 100644
--- a/src/plugins/generic/evdevtouch/evdevtouch.pro
+++ b/src/plugins/generic/evdevtouch/evdevtouch.pro
@@ -1,10 +1,5 @@
 TARGET = qevdevtouchplugin
 
-PLUGIN_TYPE = generic
-PLUGIN_EXTENDS = -
-PLUGIN_CLASS_NAME = QEvdevTouchScreenPlugin
-load(qt_plugin)
-
 SOURCES = main.cpp
 
 QT += core-private platformsupport-private gui-private
@@ -12,3 +7,7 @@ QT += core-private platformsupport-private gui-private
 OTHER_FILES += \
     evdevtouch.json
 
+PLUGIN_TYPE = generic
+PLUGIN_EXTENDS = -
+PLUGIN_CLASS_NAME = QEvdevTouchScreenPlugin
+load(qt_plugin)
diff --git a/src/plugins/generic/libinput/libinput.pro b/src/plugins/generic/libinput/libinput.pro
index 17dbb23ef0b..335605d354a 100644
--- a/src/plugins/generic/libinput/libinput.pro
+++ b/src/plugins/generic/libinput/libinput.pro
@@ -1,12 +1,12 @@
 TARGET = qlibinputplugin
 
-PLUGIN_TYPE = generic
-PLUGIN_EXTENDS = -
-PLUGIN_CLASS_NAME = QLibInputPlugin
-load(qt_plugin)
-
 QT += core-private platformsupport-private gui-private
 
 SOURCES = main.cpp
 
 OTHER_FILES = libinput.json
+
+PLUGIN_TYPE = generic
+PLUGIN_EXTENDS = -
+PLUGIN_CLASS_NAME = QLibInputPlugin
+load(qt_plugin)
diff --git a/src/plugins/generic/tslib/tslib.pro b/src/plugins/generic/tslib/tslib.pro
index be6fc4fbea9..200d231cc8e 100644
--- a/src/plugins/generic/tslib/tslib.pro
+++ b/src/plugins/generic/tslib/tslib.pro
@@ -1,10 +1,5 @@
 TARGET = qtslibplugin
 
-PLUGIN_TYPE = generic
-PLUGIN_EXTENDS = -
-PLUGIN_CLASS_NAME = QTsLibPlugin
-load(qt_plugin)
-
 SOURCES = main.cpp
 
 QT += gui-private platformsupport-private
@@ -12,3 +7,8 @@ QT += gui-private platformsupport-private
 LIBS += -lts
 
 OTHER_FILES += tslib.json
+
+PLUGIN_TYPE = generic
+PLUGIN_EXTENDS = -
+PLUGIN_CLASS_NAME = QTsLibPlugin
+load(qt_plugin)
diff --git a/src/plugins/generic/tuiotouch/qoscbundle.cpp b/src/plugins/generic/tuiotouch/qoscbundle.cpp
index ef5ca5b5f1e..26dabebd23b 100644
--- a/src/plugins/generic/tuiotouch/qoscbundle.cpp
+++ b/src/plugins/generic/tuiotouch/qoscbundle.cpp
@@ -122,7 +122,7 @@ QOscBundle::QOscBundle(const QByteArray &data)
         if (size == 0) {
             // empty bundle; these are valid, but should they be allowed? the
             // spec is unclear on this...
-            qWarning() << "Empty bundle?";
+            qWarning("Empty bundle?");
             m_isValid = true;
             m_immediate = isImmediate;
             m_timeEpoch = oscTimeEpoch;
@@ -152,7 +152,7 @@ QOscBundle::QOscBundle(const QByteArray &data)
                 m_timePico = oscTimePico;
                 m_messages.append(subMessage);
             } else {
-                qWarning() << "Invalid sub-message";
+                qWarning("Invalid sub-message");
                 return;
             }
         } else if (subdata.startsWith(bundleIdentifier)) {
@@ -166,7 +166,7 @@ QOscBundle::QOscBundle(const QByteArray &data)
                 m_bundles.append(subBundle);
             }
         } else {
-            qWarning() << "Malformed sub-data!";
+            qWarning("Malformed sub-data!");
             return;
         }
     }
diff --git a/src/plugins/generic/tuiotouch/qtuiohandler.cpp b/src/plugins/generic/tuiotouch/qtuiohandler.cpp
index e2c4bf9dc41..6026e06b558 100644
--- a/src/plugins/generic/tuiotouch/qtuiohandler.cpp
+++ b/src/plugins/generic/tuiotouch/qtuiohandler.cpp
@@ -165,7 +165,7 @@ void QTuioHandler::processPackets()
 
             QList<QVariant> arguments = message.arguments();
             if (arguments.count() == 0) {
-                qWarning() << "Ignoring TUIO message with no arguments";
+                qWarning("Ignoring TUIO message with no arguments");
                 continue;
             }
 
@@ -195,7 +195,7 @@ void QTuioHandler::process2DCurSource(const QOscMessage &message)
     }
 
     if (QMetaType::Type(arguments.at(1).type()) != QMetaType::QByteArray) {
-        qWarning() << "Ignoring malformed TUIO source message (bad argument type)";
+        qWarning("Ignoring malformed TUIO source message (bad argument type)");
         return;
     }
 
diff --git a/src/plugins/generic/tuiotouch/tuiotouch.pro b/src/plugins/generic/tuiotouch/tuiotouch.pro
index 5e53403f5b0..ae2ccde0582 100644
--- a/src/plugins/generic/tuiotouch/tuiotouch.pro
+++ b/src/plugins/generic/tuiotouch/tuiotouch.pro
@@ -1,10 +1,5 @@
 TARGET = qtuiotouchplugin
 
-PLUGIN_TYPE = generic
-PLUGIN_EXTENDS = -
-PLUGIN_CLASS_NAME = QTuioTouchPlugin
-load(qt_plugin)
-
 QT += \
     core-private \
     gui-private \
@@ -24,3 +19,8 @@ HEADERS += \
 
 OTHER_FILES += \
     tuiotouch.json
+
+PLUGIN_TYPE = generic
+PLUGIN_EXTENDS = -
+PLUGIN_CLASS_NAME = QTuioTouchPlugin
+load(qt_plugin)
diff --git a/src/plugins/imageformats/gif/gif.pro b/src/plugins/imageformats/gif/gif.pro
index 2a5048bb1c7..a361bc25321 100644
--- a/src/plugins/imageformats/gif/gif.pro
+++ b/src/plugins/imageformats/gif/gif.pro
@@ -1,11 +1,11 @@
 TARGET  = qgif
 
-PLUGIN_TYPE = imageformats
-PLUGIN_CLASS_NAME = QGifPlugin
-load(qt_plugin)
-
 include(../../../gui/image/qgifhandler.pri)
 INCLUDEPATH += ../../../gui/image
 SOURCES += $$PWD/main.cpp
 HEADERS += $$PWD/main.h
 OTHER_FILES += gif.json
+
+PLUGIN_TYPE = imageformats
+PLUGIN_CLASS_NAME = QGifPlugin
+load(qt_plugin)
diff --git a/src/plugins/imageformats/ico/ico.pro b/src/plugins/imageformats/ico/ico.pro
index 4250fcb4bcb..60afdaed709 100644
--- a/src/plugins/imageformats/ico/ico.pro
+++ b/src/plugins/imageformats/ico/ico.pro
@@ -1,12 +1,12 @@
 TARGET  = qico
 
-PLUGIN_TYPE = imageformats
-PLUGIN_CLASS_NAME = QICOPlugin
-load(qt_plugin)
-
 QTDIR_build:REQUIRES = "!contains(QT_CONFIG, no-ico)"
 
 HEADERS += qicohandler.h main.h
 SOURCES += main.cpp \
            qicohandler.cpp
 OTHER_FILES += ico.json
+
+PLUGIN_TYPE = imageformats
+PLUGIN_CLASS_NAME = QICOPlugin
+load(qt_plugin)
diff --git a/src/plugins/imageformats/jpeg/jpeg.pro b/src/plugins/imageformats/jpeg/jpeg.pro
index e33fde1cdbb..526556179c5 100644
--- a/src/plugins/imageformats/jpeg/jpeg.pro
+++ b/src/plugins/imageformats/jpeg/jpeg.pro
@@ -1,9 +1,5 @@
 TARGET  = qjpeg
 
-PLUGIN_TYPE = imageformats
-PLUGIN_CLASS_NAME = QJpegPlugin
-load(qt_plugin)
-
 QT += core-private
 
 QTDIR_build:REQUIRES = "!contains(QT_CONFIG, no-jpeg)"
@@ -13,3 +9,7 @@ INCLUDEPATH += ../../../gui/image
 SOURCES += main.cpp
 HEADERS += main.h
 OTHER_FILES += jpeg.json
+
+PLUGIN_TYPE = imageformats
+PLUGIN_CLASS_NAME = QJpegPlugin
+load(qt_plugin)
diff --git a/src/plugins/platforminputcontexts/compose/compose.pro b/src/plugins/platforminputcontexts/compose/compose.pro
index a4b5280e64c..86bdd4729ba 100644
--- a/src/plugins/platforminputcontexts/compose/compose.pro
+++ b/src/plugins/platforminputcontexts/compose/compose.pro
@@ -1,10 +1,5 @@
 TARGET = composeplatforminputcontextplugin
 
-PLUGIN_TYPE = platforminputcontexts
-PLUGIN_EXTENDS = -
-PLUGIN_CLASS_NAME = QComposePlatformInputContextPlugin
-load(qt_plugin)
-
 QT += core-private gui-private
 
 DEFINES += X11_PREFIX='\\"$$QMAKE_X11_PREFIX\\"'
@@ -27,3 +22,8 @@ contains(QT_CONFIG, xkbcommon-qt): {
 }
 
 OTHER_FILES += $$PWD/compose.json
+
+PLUGIN_TYPE = platforminputcontexts
+PLUGIN_EXTENDS = -
+PLUGIN_CLASS_NAME = QComposePlatformInputContextPlugin
+load(qt_plugin)
diff --git a/src/plugins/platforminputcontexts/ibus/ibus.pro b/src/plugins/platforminputcontexts/ibus/ibus.pro
index 401be6d42fc..9f6c848e6ac 100644
--- a/src/plugins/platforminputcontexts/ibus/ibus.pro
+++ b/src/plugins/platforminputcontexts/ibus/ibus.pro
@@ -1,10 +1,5 @@
 TARGET = ibusplatforminputcontextplugin
 
-PLUGIN_TYPE = platforminputcontexts
-PLUGIN_EXTENDS = -
-PLUGIN_CLASS_NAME = QIbusPlatformInputContextPlugin
-load(qt_plugin)
-
 QT += dbus gui-private
 SOURCES += $$PWD/qibusplatforminputcontext.cpp \
            $$PWD/qibusproxy.cpp \
@@ -18,3 +13,8 @@ HEADERS += $$PWD/qibusplatforminputcontext.h \
            $$PWD/qibustypes.h
 
 OTHER_FILES += $$PWD/ibus.json
+
+PLUGIN_TYPE = platforminputcontexts
+PLUGIN_EXTENDS = -
+PLUGIN_CLASS_NAME = QIbusPlatformInputContextPlugin
+load(qt_plugin)
diff --git a/src/plugins/platforminputcontexts/ibus/main.cpp b/src/plugins/platforminputcontexts/ibus/main.cpp
index b47c0b40de7..2846f52c8c7 100644
--- a/src/plugins/platforminputcontexts/ibus/main.cpp
+++ b/src/plugins/platforminputcontexts/ibus/main.cpp
@@ -59,7 +59,6 @@ QIBusPlatformInputContext *QIbusPlatformInputContextPlugin::create(const QString
     Q_UNUSED(paramList);
 
     if (system.compare(system, QLatin1String("ibus"), Qt::CaseInsensitive) == 0) {
-        qDBusRegisterMetaType<QIBusSerializable>();
         qDBusRegisterMetaType<QIBusAttribute>();
         qDBusRegisterMetaType<QIBusAttributeList>();
         qDBusRegisterMetaType<QIBusText>();
diff --git a/src/plugins/platforminputcontexts/ibus/qibusplatforminputcontext.cpp b/src/plugins/platforminputcontexts/ibus/qibusplatforminputcontext.cpp
index 2523b0b5dcf..994fe8386b9 100644
--- a/src/plugins/platforminputcontexts/ibus/qibusplatforminputcontext.cpp
+++ b/src/plugins/platforminputcontexts/ibus/qibusplatforminputcontext.cpp
@@ -289,7 +289,7 @@ void QIBusPlatformInputContext::updatePreeditText(const QDBusVariant &text, uint
 void QIBusPlatformInputContext::surroundingTextRequired()
 {
     if (debug)
-        qDebug() << "surroundingTextRequired";
+        qDebug("surroundingTextRequired");
     d->needsSurroundingText = true;
     update(Qt::ImSurroundingText);
 }
diff --git a/src/plugins/platforminputcontexts/ibus/qibustypes.cpp b/src/plugins/platforminputcontexts/ibus/qibustypes.cpp
index a168836a061..ac82fa39313 100644
--- a/src/plugins/platforminputcontexts/ibus/qibustypes.cpp
+++ b/src/plugins/platforminputcontexts/ibus/qibustypes.cpp
@@ -50,13 +50,9 @@ QIBusSerializable::QIBusSerializable()
 {
 }
 
-QIBusSerializable::~QIBusSerializable()
+void QIBusSerializable::deserializeFrom(const QDBusArgument &argument)
 {
-}
-
-const QDBusArgument &operator>>(const QDBusArgument &argument, QIBusSerializable &object)
-{
-    argument >> object.name;
+    argument >> name;
 
     argument.beginMap();
     while (!argument.atEnd()) {
@@ -66,19 +62,18 @@ const QDBusArgument &operator>>(const QDBusArgument &argument, QIBusSerializable
         argument >> key;
         argument >> value;
         argument.endMapEntry();
-        object.attachments[key] = value.variant().value<QDBusArgument>();
+        attachments[key] = value.variant().value<QDBusArgument>();
     }
     argument.endMap();
-    return argument;
 }
 
-QDBusArgument &operator<<(QDBusArgument &argument, const QIBusSerializable &object)
+void QIBusSerializable::serializeTo(QDBusArgument &argument) const
 {
-    argument << object.name;
+    argument << name;
 
     argument.beginMap(qMetaTypeId<QString>(), qMetaTypeId<QDBusVariant>());
 
-    QHashIterator<QString, QDBusArgument> i(object.attachments);
+    QHashIterator<QString, QDBusArgument> i(attachments);
     while (i.hasNext()) {
         i.next();
 
@@ -91,7 +86,6 @@ QDBusArgument &operator<<(QDBusArgument &argument, const QIBusSerializable &obje
         argument.endMapEntry();
     }
     argument.endMap();
-    return argument;
 }
 
 QIBusAttribute::QIBusAttribute()
@@ -103,43 +97,35 @@ QIBusAttribute::QIBusAttribute()
     name = "IBusAttribute";
 }
 
-QIBusAttribute::~QIBusAttribute()
-{
-}
-
-QDBusArgument &operator<<(QDBusArgument &argument, const QIBusAttribute &attribute)
+void QIBusAttribute::serializeTo(QDBusArgument &argument) const
 {
     argument.beginStructure();
 
-    argument << static_cast<const QIBusSerializable &>(attribute);
+    QIBusSerializable::serializeTo(argument);
 
-    quint32 t = (quint32) attribute.type;
+    quint32 t = (quint32) type;
     argument << t;
-    argument << attribute.value;
-    argument << attribute.start;
-    argument << attribute.end;
+    argument << value;
+    argument << start;
+    argument << end;
 
     argument.endStructure();
-
-    return argument;
 }
 
-const QDBusArgument &operator>>(const QDBusArgument &argument, QIBusAttribute &attribute)
+void QIBusAttribute::deserializeFrom(const QDBusArgument &argument)
 {
     argument.beginStructure();
 
-    argument >> static_cast<QIBusSerializable &>(attribute);
+    QIBusSerializable::deserializeFrom(argument);
 
     quint32 t;
     argument >> t;
-    attribute.type = (QIBusAttribute::Type) t;
-    argument >> attribute.value;
-    argument >> attribute.start;
-    argument >> attribute.end;
+    type = (QIBusAttribute::Type) t;
+    argument >> value;
+    argument >> start;
+    argument >> end;
 
     argument.endStructure();
-
-    return argument;
 }
 
 QTextCharFormat QIBusAttribute::format() const
@@ -187,34 +173,30 @@ QIBusAttributeList::QIBusAttributeList()
     name = "IBusAttrList";
 }
 
-QIBusAttributeList::~QIBusAttributeList()
-{
-}
-
-QDBusArgument &operator<<(QDBusArgument &argument, const QIBusAttributeList &attrList)
+void QIBusAttributeList::serializeTo(QDBusArgument &argument) const
 {
     argument.beginStructure();
 
-    argument << static_cast<const QIBusSerializable &>(attrList);
+    QIBusSerializable::serializeTo(argument);
 
     argument.beginArray(qMetaTypeId<QDBusVariant>());
-    for (int i = 0; i < attrList.attributes.size(); ++i) {
+    for (int i = 0; i < attributes.size(); ++i) {
         QVariant variant;
-        variant.setValue(attrList.attributes.at(i));
+        variant.setValue(attributes.at(i));
         argument << QDBusVariant (variant);
     }
     argument.endArray();
 
     argument.endStructure();
-    return argument;
 }
 
-const QDBusArgument &operator>>(const QDBusArgument &arg, QIBusAttributeList &attrList)
+void QIBusAttributeList::deserializeFrom(const QDBusArgument &arg)
 {
     qCDebug(qtQpaInputMethodsSerialize) << "QIBusAttributeList::fromDBusArgument()" << arg.currentSignature();
+
     arg.beginStructure();
 
-    arg >> static_cast<QIBusSerializable &>(attrList);
+    QIBusSerializable::deserializeFrom(arg);
 
     arg.beginArray();
     while (!arg.atEnd()) {
@@ -223,12 +205,11 @@ const QDBusArgument &operator>>(const QDBusArgument &arg, QIBusAttributeList &at
 
         QIBusAttribute attr;
         var.variant().value<QDBusArgument>() >> attr;
-        attrList.attributes.append(attr);
+        attributes.append(std::move(attr));
     }
     arg.endArray();
 
     arg.endStructure();
-    return arg;
 }
 
 QList<QInputMethodEvent::Attribute> QIBusAttributeList::imAttributes() const
@@ -269,138 +250,115 @@ QIBusText::QIBusText()
     name = "IBusText";
 }
 
-QIBusText::~QIBusText()
-{
-}
-
-QDBusArgument &operator<<(QDBusArgument &argument, const QIBusText &text)
+void QIBusText::serializeTo(QDBusArgument &argument) const
 {
     argument.beginStructure();
 
-    argument << static_cast<const QIBusSerializable &>(text);
+    QIBusSerializable::serializeTo(argument);
 
-    argument << text.text << text.attributes;
+    argument << text << attributes;
     argument.endStructure();
-    return argument;
 }
 
-const QDBusArgument &operator>>(const QDBusArgument &argument, QIBusText &text)
+void QIBusText::deserializeFrom(const QDBusArgument &argument)
 {
     qCDebug(qtQpaInputMethodsSerialize) << "QIBusText::fromDBusArgument()" << argument.currentSignature();
+
     argument.beginStructure();
 
-    argument >> static_cast<QIBusSerializable &>(text);
+    QIBusSerializable::deserializeFrom(argument);
 
-    argument >> text.text;
+    argument >> text;
     QDBusVariant variant;
     argument >> variant;
-    variant.variant().value<QDBusArgument>() >> text.attributes;
+    variant.variant().value<QDBusArgument>() >> attributes;
 
     argument.endStructure();
-    return argument;
 }
 
 QIBusEngineDesc::QIBusEngineDesc()
-    : engine_name(""),
-      longname(""),
-      description(""),
-      language(""),
-      license(""),
-      author(""),
-      icon(""),
-      layout(""),
-      rank(0),
-      hotkeys(""),
-      symbol(""),
-      setup(""),
-      layout_variant(""),
-      layout_option(""),
-      version(""),
-      textdomain(""),
-      iconpropkey("")
+    : rank(0)
 {
     name = "IBusEngineDesc";
 }
 
-QIBusEngineDesc::~QIBusEngineDesc()
-{
-}
-
-QDBusArgument &operator<<(QDBusArgument &argument, const QIBusEngineDesc &desc)
+void QIBusEngineDesc::serializeTo(QDBusArgument &argument) const
 {
     argument.beginStructure();
 
-    argument << static_cast<const QIBusSerializable &>(desc);
+    QIBusSerializable::serializeTo(argument);
 
-    argument << desc.engine_name;
-    argument << desc.longname;
-    argument << desc.description;
-    argument << desc.language;
-    argument << desc.license;
-    argument << desc.author;
-    argument << desc.icon;
-    argument << desc.layout;
-    argument << desc.rank;
-    argument << desc.hotkeys;
-    argument << desc.symbol;
-    argument << desc.setup;
-    argument << desc.layout_variant;
-    argument << desc.layout_option;
-    argument << desc.version;
-    argument << desc.textdomain;
-    argument << desc.iconpropkey;
+    argument << engine_name;
+    argument << longname;
+    argument << description;
+    argument << language;
+    argument << license;
+    argument << author;
+    argument << icon;
+    argument << layout;
+    argument << rank;
+    argument << hotkeys;
+    argument << symbol;
+    argument << setup;
+    argument << layout_variant;
+    argument << layout_option;
+    argument << version;
+    argument << textdomain;
+    argument << iconpropkey;
 
     argument.endStructure();
-    return argument;
 }
 
-const QDBusArgument &operator>>(const QDBusArgument &argument, QIBusEngineDesc &desc)
+void QIBusEngineDesc::deserializeFrom(const QDBusArgument &argument)
 {
     qCDebug(qtQpaInputMethodsSerialize) << "QIBusEngineDesc::fromDBusArgument()" << argument.currentSignature();
     argument.beginStructure();
 
-    argument >> static_cast<QIBusSerializable &>(desc);
+    QIBusSerializable::deserializeFrom(argument);
 
-    argument >> desc.engine_name;
-    argument >> desc.longname;
-    argument >> desc.description;
-    argument >> desc.language;
-    argument >> desc.license;
-    argument >> desc.author;
-    argument >> desc.icon;
-    argument >> desc.layout;
-    argument >> desc.rank;
-    argument >> desc.hotkeys;
-    argument >> desc.symbol;
-    argument >> desc.setup;
+    argument >> engine_name;
+    argument >> longname;
+    argument >> description;
+    argument >> language;
+    argument >> license;
+    argument >> author;
+    argument >> icon;
+    argument >> layout;
+    argument >> rank;
+    argument >> hotkeys;
+    argument >> symbol;
+    argument >> setup;
     // Previous IBusEngineDesc supports the arguments between engine_name
     // and setup.
-    if (argument.currentSignature() == "") {
-        argument.endStructure();
-        return argument;
-    }
-    argument >> desc.layout_variant;
-    argument >> desc.layout_option;
+    if (argument.currentSignature() == "")
+        goto olderThanV2;
+    argument >> layout_variant;
+    argument >> layout_option;
     // Previous IBusEngineDesc supports the arguments between engine_name
     // and layout_option.
-    if (argument.currentSignature() == "") {
-        argument.endStructure();
-        return argument;
-    }
-    argument >> desc.version;
-    if (argument.currentSignature() == "") {
-        argument.endStructure();
-        return argument;
-    }
-    argument >> desc.textdomain;
-    if (argument.currentSignature() == "") {
-        argument.endStructure();
-        return argument;
-    }
-    argument >> desc.iconpropkey;
-
+    if (argument.currentSignature() == "")
+        goto olderThanV3;
+    argument >> version;
+    if (argument.currentSignature() == "")
+        goto olderThanV4;
+    argument >> textdomain;
+    if (argument.currentSignature() == "")
+        goto olderThanV5;
+    argument >> iconpropkey;
+    // <-- insert new member streaming here (1/2)
+    goto newest;
+olderThanV2:
+    layout_variant.clear();
+    layout_option.clear();
+olderThanV3:
+    version.clear();
+olderThanV4:
+    textdomain.clear();
+olderThanV5:
+    iconpropkey.clear();
+    // <-- insert new members here (2/2)
+newest:
     argument.endStructure();
-    return argument;
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/platforminputcontexts/ibus/qibustypes.h b/src/plugins/platforminputcontexts/ibus/qibustypes.h
index 9dca7e39033..217cd836fcc 100644
--- a/src/plugins/platforminputcontexts/ibus/qibustypes.h
+++ b/src/plugins/platforminputcontexts/ibus/qibustypes.h
@@ -54,13 +54,15 @@ class QIBusSerializable
 {
 public:
     QIBusSerializable();
-    virtual ~QIBusSerializable();
+
+    void serializeTo(QDBusArgument &argument) const;
+    void deserializeFrom(const QDBusArgument &argument);
 
     QString name;
     QHash<QString, QDBusArgument>  attachments;
 };
 
-class QIBusAttribute : public QIBusSerializable
+class QIBusAttribute : private QIBusSerializable
 {
 public:
     enum Type {
@@ -79,42 +81,53 @@ public:
     };
 
     QIBusAttribute();
-    ~QIBusAttribute();
 
     QTextCharFormat format() const;
 
+    void serializeTo(QDBusArgument &argument) const;
+    void deserializeFrom(const QDBusArgument &argument);
+
     Type type;
     quint32 value;
     quint32 start;
     quint32 end;
 };
+Q_DECLARE_TYPEINFO(QIBusAttribute, Q_MOVABLE_TYPE);
 
-class QIBusAttributeList : public QIBusSerializable
+class QIBusAttributeList : private QIBusSerializable
 {
 public:
     QIBusAttributeList();
-    ~QIBusAttributeList();
 
     QList<QInputMethodEvent::Attribute> imAttributes() const;
 
+    void serializeTo(QDBusArgument &argument) const;
+    void deserializeFrom(const QDBusArgument &argument);
+
     QVector<QIBusAttribute> attributes;
 };
+Q_DECLARE_TYPEINFO(QIBusAttributeList, Q_MOVABLE_TYPE);
 
-class QIBusText : public QIBusSerializable
+class QIBusText : private QIBusSerializable
 {
 public:
     QIBusText();
-    ~QIBusText();
+
+    void serializeTo(QDBusArgument &argument) const;
+    void deserializeFrom(const QDBusArgument &argument);
 
     QString text;
     QIBusAttributeList attributes;
 };
+Q_DECLARE_TYPEINFO(QIBusText, Q_MOVABLE_TYPE);
 
-class QIBusEngineDesc : public QIBusSerializable
+class QIBusEngineDesc : private QIBusSerializable
 {
 public:
     QIBusEngineDesc();
-    ~QIBusEngineDesc();
+
+    void serializeTo(QDBusArgument &argument) const;
+    void deserializeFrom(const QDBusArgument &argument);
 
     QString engine_name;
     QString longname;
@@ -134,25 +147,30 @@ public:
     QString textdomain;
     QString iconpropkey;
 };
+Q_DECLARE_TYPEINFO(QIBusEngineDesc, Q_MOVABLE_TYPE);
 
-QDBusArgument &operator<<(QDBusArgument &argument, const QIBusSerializable &object);
-const QDBusArgument &operator>>(const QDBusArgument &argument, QIBusSerializable &object);
+inline QDBusArgument &operator<<(QDBusArgument &argument, const QIBusAttribute &attribute)
+{ attribute.serializeTo(argument); return argument; }
+inline const QDBusArgument &operator>>(const QDBusArgument &argument, QIBusAttribute &attribute)
+{ attribute.deserializeFrom(argument); return argument; }
 
-QDBusArgument &operator<<(QDBusArgument &argument, const QIBusAttribute &attribute);
-const QDBusArgument &operator>>(const QDBusArgument &argument, QIBusAttribute &attribute);
+inline QDBusArgument &operator<<(QDBusArgument &argument, const QIBusAttributeList &attributeList)
+{ attributeList.serializeTo(argument); return argument; }
+inline const QDBusArgument &operator>>(const QDBusArgument &argument, QIBusAttributeList &attributeList)
+{ attributeList.deserializeFrom(argument); return argument; }
 
-QDBusArgument &operator<<(QDBusArgument &argument, const QIBusAttributeList &attributeList);
-const QDBusArgument &operator>>(const QDBusArgument &arg, QIBusAttributeList &attrList);
+inline QDBusArgument &operator<<(QDBusArgument &argument, const QIBusText &text)
+{ text.serializeTo(argument); return argument; }
+inline const QDBusArgument &operator>>(const QDBusArgument &argument, QIBusText &text)
+{ text.deserializeFrom(argument); return argument; }
 
-QDBusArgument &operator<<(QDBusArgument &argument, const QIBusText &text);
-const QDBusArgument &operator>>(const QDBusArgument &argument, QIBusText &text);
-
-QDBusArgument &operator<<(QDBusArgument &argument, const QIBusEngineDesc &desc);
-const QDBusArgument &operator>>(const QDBusArgument &argument, QIBusEngineDesc &desc);
+inline QDBusArgument &operator<<(QDBusArgument &argument, const QIBusEngineDesc &desc)
+{ desc.serializeTo(argument); return argument; }
+inline const QDBusArgument &operator>>(const QDBusArgument &argument, QIBusEngineDesc &desc)
+{ desc.deserializeFrom(argument); return argument; }
 
 QT_END_NAMESPACE
 
-Q_DECLARE_METATYPE(QIBusSerializable)
 Q_DECLARE_METATYPE(QIBusAttribute)
 Q_DECLARE_METATYPE(QIBusAttributeList)
 Q_DECLARE_METATYPE(QIBusText)
diff --git a/src/plugins/platforms/android/android.pro b/src/plugins/platforms/android/android.pro
index 3ba817bf5bc..045e55ec657 100644
--- a/src/plugins/platforms/android/android.pro
+++ b/src/plugins/platforms/android/android.pro
@@ -1,13 +1,9 @@
 TARGET = qtforandroid
 
-PLUGIN_TYPE = platforms
-
 # STATICPLUGIN needed because there's a Q_IMPORT_PLUGIN in androidjnimain.cpp
 # Yes, the plugin imports itself statically
 DEFINES += QT_STATICPLUGIN
 
-load(qt_plugin)
-
 LIBS += -ljnigraphics -landroid
 
 QT += core-private gui-private platformsupport-private
@@ -79,6 +75,9 @@ HEADERS += $$PWD/qandroidplatformintegration.h \
 android-style-assets: SOURCES += $$PWD/extract.cpp
 else: SOURCES += $$PWD/extract-dummy.cpp
 
+PLUGIN_TYPE = platforms
+load(qt_plugin)
+
 #Non-standard install directory, QTBUG-29859
 DESTDIR = $$DESTDIR/android
 target.path = $${target.path}/android
diff --git a/src/plugins/platforms/android/androidjniinput.cpp b/src/plugins/platforms/android/androidjniinput.cpp
index e680a0ed34c..064a0c095c1 100644
--- a/src/plugins/platforms/android/androidjniinput.cpp
+++ b/src/plugins/platforms/android/androidjniinput.cpp
@@ -98,7 +98,7 @@ namespace QtAndroidInput
     {
         QJNIObjectPrivate::callStaticMethod<void>(applicationClass(), "resetSoftwareKeyboard");
 #ifdef QT_DEBUG_ANDROID_IM_PROTOCOL
-        qDebug() << "@@@ RESETSOFTWAREKEYBOARD";
+        qDebug("@@@ RESETSOFTWAREKEYBOARD");
 #endif
     }
 
@@ -106,7 +106,7 @@ namespace QtAndroidInput
     {
         QJNIObjectPrivate::callStaticMethod<void>(applicationClass(), "hideSoftwareKeyboard");
 #ifdef QT_DEBUG_ANDROID_IM_PROTOCOL
-        qDebug() << "@@@ HIDESOFTWAREKEYBOARD";
+        qDebug("@@@ HIDESOFTWAREKEYBOARD");
 #endif
     }
 
diff --git a/src/plugins/platforms/android/androidjnimain.cpp b/src/plugins/platforms/android/androidjnimain.cpp
index 6340d47c18c..516fe60c8c8 100644
--- a/src/plugins/platforms/android/androidjnimain.cpp
+++ b/src/plugins/platforms/android/androidjnimain.cpp
@@ -521,7 +521,7 @@ static jboolean startQtApplication(JNIEnv *env, jobject /*object*/, jstring para
         }
         m_main = (Main)dlsym(m_mainLibraryHnd, "main");
     } else {
-        qWarning() << "No main library was specified; searching entire process (this is slow!)";
+        qWarning("No main library was specified; searching entire process (this is slow!)");
         m_main = (Main)dlsym(RTLD_DEFAULT, "main");
     }
 
diff --git a/src/plugins/platforms/android/qandroidinputcontext.cpp b/src/plugins/platforms/android/qandroidinputcontext.cpp
index b73be718c0a..c09dfeda436 100644
--- a/src/plugins/platforms/android/qandroidinputcontext.cpp
+++ b/src/plugins/platforms/android/qandroidinputcontext.cpp
@@ -78,7 +78,7 @@ static jboolean beginBatchEdit(JNIEnv */*env*/, jobject /*thiz*/)
         return JNI_FALSE;
 
 #ifdef QT_DEBUG_ANDROID_IM_PROTOCOL
-    qDebug() << "@@@ BEGINBATCH";
+    qDebug("@@@ BEGINBATCH");
 #endif
 
     return m_androidInputContext->beginBatchEdit();
@@ -92,7 +92,7 @@ static jboolean endBatchEdit(JNIEnv */*env*/, jobject /*thiz*/)
         return JNI_FALSE;
 
 #ifdef QT_DEBUG_ANDROID_IM_PROTOCOL
-    qDebug() << "@@@ ENDBATCH";
+    qDebug("@@@ ENDBATCH");
 #endif
 
     return m_androidInputContext->endBatchEdit();
@@ -134,7 +134,7 @@ static jboolean finishComposingText(JNIEnv */*env*/, jobject /*thiz*/)
         return JNI_FALSE;
 
 #ifdef QT_DEBUG_ANDROID_IM_PROTOCOL
-    qDebug() << "@@@ FINISH";
+    qDebug("@@@ FINISH");
 #endif
     return m_androidInputContext->finishComposingText();
 }
@@ -256,7 +256,7 @@ static jboolean selectAll(JNIEnv */*env*/, jobject /*thiz*/)
         return JNI_FALSE;
 
 #ifdef QT_DEBUG_ANDROID_IM_PROTOCOL
-    qDebug() << "@@@ SELALL";
+    qDebug("@@@ SELALL");
 #endif
     return m_androidInputContext->selectAll();
 }
@@ -267,7 +267,7 @@ static jboolean cut(JNIEnv */*env*/, jobject /*thiz*/)
         return JNI_FALSE;
 
 #ifdef QT_DEBUG_ANDROID_IM_PROTOCOL
-    qDebug() << "@@@";
+    qDebug("@@@");
 #endif
     return m_androidInputContext->cut();
 }
@@ -278,7 +278,7 @@ static jboolean copy(JNIEnv */*env*/, jobject /*thiz*/)
         return JNI_FALSE;
 
 #ifdef QT_DEBUG_ANDROID_IM_PROTOCOL
-    qDebug() << "@@@";
+    qDebug("@@@");
 #endif
     return m_androidInputContext->copy();
 }
@@ -289,7 +289,7 @@ static jboolean copyURL(JNIEnv */*env*/, jobject /*thiz*/)
         return JNI_FALSE;
 
 #ifdef QT_DEBUG_ANDROID_IM_PROTOCOL
-    qDebug() << "@@@";
+    qDebug("@@@");
 #endif
     return m_androidInputContext->copyURL();
 }
@@ -300,7 +300,7 @@ static jboolean paste(JNIEnv */*env*/, jobject /*thiz*/)
         return JNI_FALSE;
 
 #ifdef QT_DEBUG_ANDROID_IM_PROTOCOL
-    qDebug() << "@@@";
+    qDebug("@@@");
 #endif
     return m_androidInputContext->paste();
 }
@@ -311,7 +311,7 @@ static jboolean updateCursorPosition(JNIEnv */*env*/, jobject /*thiz*/)
         return JNI_FALSE;
 
 #ifdef QT_DEBUG_ANDROID_IM_PROTOCOL
-    qDebug() << "@@@ UPDATECURSORPOS";
+    qDebug("@@@ UPDATECURSORPOS");
 #endif
     m_androidInputContext->updateCursorPosition();
     return true;
@@ -371,43 +371,43 @@ QAndroidInputContext::QAndroidInputContext()
     m_extractedTextClass = static_cast<jclass>(env->NewGlobalRef(clazz));
     m_classConstructorMethodID = env->GetMethodID(m_extractedTextClass, "<init>", "()V");
     if (Q_UNLIKELY(!m_classConstructorMethodID)) {
-        qCritical() << "GetMethodID failed";
+        qCritical("GetMethodID failed");
         return;
     }
 
     m_partialEndOffsetFieldID = env->GetFieldID(m_extractedTextClass, "partialEndOffset", "I");
     if (Q_UNLIKELY(!m_partialEndOffsetFieldID)) {
-        qCritical() << "Can't find field partialEndOffset";
+        qCritical("Can't find field partialEndOffset");
         return;
     }
 
     m_partialStartOffsetFieldID = env->GetFieldID(m_extractedTextClass, "partialStartOffset", "I");
     if (Q_UNLIKELY(!m_partialStartOffsetFieldID)) {
-        qCritical() << "Can't find field partialStartOffset";
+        qCritical("Can't find field partialStartOffset");
         return;
     }
 
     m_selectionEndFieldID = env->GetFieldID(m_extractedTextClass, "selectionEnd", "I");
     if (Q_UNLIKELY(!m_selectionEndFieldID)) {
-        qCritical() << "Can't find field selectionEnd";
+        qCritical("Can't find field selectionEnd");
         return;
     }
 
     m_selectionStartFieldID = env->GetFieldID(m_extractedTextClass, "selectionStart", "I");
     if (Q_UNLIKELY(!m_selectionStartFieldID)) {
-        qCritical() << "Can't find field selectionStart";
+        qCritical("Can't find field selectionStart");
         return;
     }
 
     m_startOffsetFieldID = env->GetFieldID(m_extractedTextClass, "startOffset", "I");
     if (Q_UNLIKELY(!m_startOffsetFieldID)) {
-        qCritical() << "Can't find field startOffset";
+        qCritical("Can't find field startOffset");
         return;
     }
 
     m_textFieldID = env->GetFieldID(m_extractedTextClass, "text", "Ljava/lang/String;");
     if (Q_UNLIKELY(!m_textFieldID)) {
-        qCritical() << "Can't find field text";
+        qCritical("Can't find field text");
         return;
     }
     qRegisterMetaType<QInputMethodEvent *>("QInputMethodEvent*");
diff --git a/src/plugins/platforms/android/qandroidplatformtheme.cpp b/src/plugins/platforms/android/qandroidplatformtheme.cpp
index 7bed4a739ad..f8d0b9c8bae 100644
--- a/src/plugins/platforms/android/qandroidplatformtheme.cpp
+++ b/src/plugins/platforms/android/qandroidplatformtheme.cpp
@@ -216,7 +216,7 @@ QJsonObject AndroidStyle::loadStyleData()
     }
 
     if (Q_UNLIKELY(!document.isObject())) {
-        qCritical() << "Style.json does not contain a valid style.";
+        qCritical("Style.json does not contain a valid style.");
         return QJsonObject();
     }
     return document.object();
diff --git a/src/plugins/platforms/cocoa/cocoa.pro b/src/plugins/platforms/cocoa/cocoa.pro
index fec1da334f7..02d8b161100 100644
--- a/src/plugins/platforms/cocoa/cocoa.pro
+++ b/src/plugins/platforms/cocoa/cocoa.pro
@@ -1,10 +1,5 @@
 TARGET = qcocoa
 
-PLUGIN_TYPE = platforms
-PLUGIN_CLASS_NAME = QCocoaIntegrationPlugin
-!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
-load(qt_plugin)
-
 OBJECTIVE_SOURCES += main.mm \
     qcocoaintegration.mm \
     qcocoatheme.mm \
@@ -110,5 +105,8 @@ OTHER_FILES += cocoa.json
 # DEFINES += QT_COCOA_ENABLE_ACCESSIBILITY_INSPECTOR
 # include ($$PWD/../../../../util/accessibilityinspector/accessibilityinspector.pri)
 
-# Window debug support
-#DEFINES += QT_COCOA_ENABLE_WINDOW_DEBUG
+
+PLUGIN_TYPE = platforms
+PLUGIN_CLASS_NAME = QCocoaIntegrationPlugin
+!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
+load(qt_plugin)
diff --git a/src/plugins/platforms/cocoa/qcocoaaccessibility.mm b/src/plugins/platforms/cocoa/qcocoaaccessibility.mm
index bc4cb227a81..1faa8064803 100644
--- a/src/plugins/platforms/cocoa/qcocoaaccessibility.mm
+++ b/src/plugins/platforms/cocoa/qcocoaaccessibility.mm
@@ -63,7 +63,7 @@ void QCocoaAccessibility::notifyAccessibilityUpdate(QAccessibleEvent *event)
         return;
     QMacAccessibilityElement *element = [QMacAccessibilityElement elementWithId: event->uniqueId()];
     if (!element) {
-        qWarning() << "QCocoaAccessibility::notifyAccessibilityUpdate: invalid element";
+        qWarning("QCocoaAccessibility::notifyAccessibilityUpdate: invalid element");
         return;
     }
 
@@ -277,7 +277,7 @@ NSArray *unignoredChildren(QAccessibleInterface *interface)
         if (element)
             [kids addObject: element];
         else
-            qWarning() << "QCocoaAccessibility: invalid child";
+            qWarning("QCocoaAccessibility: invalid child");
     }
     return NSAccessibilityUnignoredChildren(kids);
 }
diff --git a/src/plugins/platforms/cocoa/qcocoaaccessibilityelement.mm b/src/plugins/platforms/cocoa/qcocoaaccessibilityelement.mm
index 0f8081715b4..7128fb72c30 100644
--- a/src/plugins/platforms/cocoa/qcocoaaccessibilityelement.mm
+++ b/src/plugins/platforms/cocoa/qcocoaaccessibilityelement.mm
@@ -555,7 +555,7 @@ static void convertLineOffset(QAccessibleTextInterface *text, int *line, int *of
 - (id)accessibilityHitTest:(NSPoint)point {
     QAccessibleInterface *iface = QAccessible::accessibleInterface(axid);
     if (!iface || !iface->isValid()) {
-//        qDebug() << "Hit test: INVALID";
+//        qDebug("Hit test: INVALID");
         return NSAccessibilityUnignoredAncestor(self);
     }
 
@@ -585,7 +585,7 @@ static void convertLineOffset(QAccessibleTextInterface *text, int *line, int *of
     QAccessibleInterface *iface = QAccessible::accessibleInterface(axid);
 
     if (!iface || !iface->isValid()) {
-        qWarning() << "FocusedUIElement for INVALID";
+        qWarning("FocusedUIElement for INVALID");
         return nil;
     }
 
diff --git a/src/plugins/platforms/cocoa/qcocoabackingstore.h b/src/plugins/platforms/cocoa/qcocoabackingstore.h
index 18673a36671..fa05626d180 100644
--- a/src/plugins/platforms/cocoa/qcocoabackingstore.h
+++ b/src/plugins/platforms/cocoa/qcocoabackingstore.h
@@ -57,7 +57,11 @@ public:
 
     QPaintDevice *paintDevice() Q_DECL_OVERRIDE;
     void flush(QWindow *widget, const QRegion &region, const QPoint &offset) Q_DECL_OVERRIDE;
+#ifndef QT_NO_OPENGL
     QImage toImage() const Q_DECL_OVERRIDE;
+#else
+    QImage toImage() const; // No QPlatformBackingStore::toImage() for NO_OPENGL builds.
+#endif
     void resize (const QSize &size, const QRegion &) Q_DECL_OVERRIDE;
     bool scroll(const QRegion &area, int dx, int dy) Q_DECL_OVERRIDE;
     void beginPaint(const QRegion &region) Q_DECL_OVERRIDE;
diff --git a/src/plugins/platforms/cocoa/qcocoaglcontext.h b/src/plugins/platforms/cocoa/qcocoaglcontext.h
index cca541e0e38..5bee708b76b 100644
--- a/src/plugins/platforms/cocoa/qcocoaglcontext.h
+++ b/src/plugins/platforms/cocoa/qcocoaglcontext.h
@@ -63,7 +63,7 @@ public:
     bool makeCurrent(QPlatformSurface *surface) Q_DECL_OVERRIDE;
     void doneCurrent() Q_DECL_OVERRIDE;
 
-    void (*getProcAddress(const QByteArray &procName)) () Q_DECL_OVERRIDE;
+    QFunctionPointer getProcAddress(const char *procName) Q_DECL_OVERRIDE;
 
     void update();
 
diff --git a/src/plugins/platforms/cocoa/qcocoaglcontext.mm b/src/plugins/platforms/cocoa/qcocoaglcontext.mm
index e4712d88bc6..7a129699720 100644
--- a/src/plugins/platforms/cocoa/qcocoaglcontext.mm
+++ b/src/plugins/platforms/cocoa/qcocoaglcontext.mm
@@ -44,6 +44,7 @@
 #include <QtCore/private/qcore_mac_p.h>
 #include <QtPlatformSupport/private/cglconvenience_p.h>
 #include <QtPlatformHeaders/qcocoanativecontext.h>
+#include <dlfcn.h>
 
 #import <AppKit/AppKit.h>
 
@@ -335,9 +336,9 @@ void QCocoaGLContext::doneCurrent()
     [NSOpenGLContext clearCurrentContext];
 }
 
-void (*QCocoaGLContext::getProcAddress(const QByteArray &procName))()
+QFunctionPointer QCocoaGLContext::getProcAddress(const char *procName)
 {
-    return qcgl_getProcAddress(procName);
+    return (QFunctionPointer)dlsym(RTLD_DEFAULT, procName);
 }
 
 void QCocoaGLContext::update()
diff --git a/src/plugins/platforms/cocoa/qcocoahelpers.h b/src/plugins/platforms/cocoa/qcocoahelpers.h
index 766561a2643..ec2f7f8cf1f 100644
--- a/src/plugins/platforms/cocoa/qcocoahelpers.h
+++ b/src/plugins/platforms/cocoa/qcocoahelpers.h
@@ -57,6 +57,8 @@
 
 QT_BEGIN_NAMESPACE
 
+Q_DECLARE_LOGGING_CATEGORY(lcQpaCocoaWindow)
+
 class QPixmap;
 class QString;
 
diff --git a/src/plugins/platforms/cocoa/qcocoahelpers.mm b/src/plugins/platforms/cocoa/qcocoahelpers.mm
index b6b1862d80b..c91c67fe796 100644
--- a/src/plugins/platforms/cocoa/qcocoahelpers.mm
+++ b/src/plugins/platforms/cocoa/qcocoahelpers.mm
@@ -77,6 +77,8 @@
 
 QT_BEGIN_NAMESPACE
 
+Q_LOGGING_CATEGORY(lcQpaCocoaWindow, "qt.qpa.cocoa.window");
+
 //
 // Conversion Functions
 //
@@ -766,11 +768,11 @@ CGContextRef qt_mac_cg_context(QPaintDevice *pdev)
         if (data && data->classId() == QPlatformPixmap::RasterClass) {
             image = data->buffer();
         } else {
-            qDebug() << "qt_mac_cg_context: Unsupported pixmap class";
+            qDebug("qt_mac_cg_context: Unsupported pixmap class");
         }
     } else if (pdev->devType() == QInternal::Widget) {
         // TODO test: image = static_cast<QImage *>(static_cast<const QWidget *>(pdev)->backingStore()->paintDevice());
-        qDebug() << "qt_mac_cg_context: not implemented: Widget class";
+        qDebug("qt_mac_cg_context: not implemented: Widget class");
     }
 
     if (!image)
diff --git a/src/plugins/platforms/cocoa/qcocoaintegration.mm b/src/plugins/platforms/cocoa/qcocoaintegration.mm
index f98ddbb14fa..c021a551a7f 100644
--- a/src/plugins/platforms/cocoa/qcocoaintegration.mm
+++ b/src/plugins/platforms/cocoa/qcocoaintegration.mm
@@ -428,14 +428,18 @@ void QCocoaIntegration::updateScreens()
         }
         siblings << screen;
     }
+
+    // Set virtual siblings list. All screens in mScreens are siblings, because we ignored the
+    // mirrors. Note that some of the screens we update the siblings list for here may be deleted
+    // below, but update anyway to keep the to-be-deleted screens out of the siblings list.
+    foreach (QCocoaScreen* screen, mScreens)
+        screen->setVirtualSiblings(siblings);
+
     // Now the leftovers in remainingScreens are no longer current, so we can delete them.
     foreach (QCocoaScreen* screen, remainingScreens) {
         mScreens.removeOne(screen);
         destroyScreen(screen);
     }
-    // All screens in mScreens are siblings, because we ignored the mirrors.
-    foreach (QCocoaScreen* screen, mScreens)
-        screen->setVirtualSiblings(siblings);
 }
 
 QCocoaScreen *QCocoaIntegration::screenAtIndex(int index)
diff --git a/src/plugins/platforms/cocoa/qcocoamenu.h b/src/plugins/platforms/cocoa/qcocoamenu.h
index 64299c6cd28..64eeabcc2d7 100644
--- a/src/plugins/platforms/cocoa/qcocoamenu.h
+++ b/src/plugins/platforms/cocoa/qcocoamenu.h
@@ -81,8 +81,6 @@ public:
 
     inline NSMenu *nsMenu() const
         { return m_nativeMenu; }
-    inline NSMenuItem *nsMenuItem() const
-        { return m_nativeItem; }
 
     inline bool isVisible() const { return m_visible; }
 
@@ -91,11 +89,9 @@ public:
 
     QList<QCocoaMenuItem *> items() const;
     QList<QCocoaMenuItem *> merged() const;
-    void setMenuBar(QCocoaMenuBar *menuBar);
-    QCocoaMenuBar *menuBar() const;
 
-    void setContainingMenuItem(QCocoaMenuItem *menuItem);
-    QCocoaMenuItem *containingMenuItem() const;
+    void setAttachedItem(NSMenuItem *item);
+    NSMenuItem *attachedItem() const;
 
 private:
     QCocoaMenuItem *itemOrNull(int index) const;
@@ -103,13 +99,10 @@ private:
 
     QList<QCocoaMenuItem *> m_menuItems;
     NSMenu *m_nativeMenu;
-    NSMenuItem *m_nativeItem;
-    NSObject *m_delegate;
+    NSMenuItem *m_attachedItem;
     bool m_enabled;
     bool m_visible;
     quintptr m_tag;
-    QCocoaMenuBar *m_menuBar;
-    QCocoaMenuItem *m_containingMenuItem;
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/platforms/cocoa/qcocoamenu.mm b/src/plugins/platforms/cocoa/qcocoamenu.mm
index 8c576c7cbed..3fc98c071fa 100644
--- a/src/plugins/platforms/cocoa/qcocoamenu.mm
+++ b/src/plugins/platforms/cocoa/qcocoamenu.mm
@@ -102,6 +102,28 @@ QT_NAMESPACE_ALIAS_OBJC_CLASS(QCocoaMenuDelegate);
     return self;
 }
 
+- (NSInteger)numberOfItemsInMenu:(NSMenu *)menu
+{
+    Q_ASSERT(m_menu->nsMenu() == menu);
+    return m_menu->items().count();
+}
+
+- (BOOL)menu:(NSMenu *)menu updateItem:(NSMenuItem *)item atIndex:(NSInteger)index shouldCancel:(BOOL)shouldCancel
+{
+    Q_UNUSED(index);
+    Q_ASSERT(m_menu->nsMenu() == menu);
+    if (shouldCancel) {
+        // TODO detach all submenus
+        return NO;
+    }
+
+    QCocoaMenuItem *menuItem = reinterpret_cast<QCocoaMenuItem *>(item.tag);
+    if (m_menu->items().contains(menuItem)) {
+        if (QCocoaMenu *itemSubmenu = menuItem->menu())
+            itemSubmenu->setAttachedItem(item);
+    }
+    return YES;
+}
 
 - (void)menu:(NSMenu*)menu willHighlightItem:(NSMenuItem*)item
 {
@@ -234,20 +256,16 @@ QT_NAMESPACE_ALIAS_OBJC_CLASS(QCocoaMenuDelegate);
 QT_BEGIN_NAMESPACE
 
 QCocoaMenu::QCocoaMenu() :
+    m_attachedItem(0),
     m_enabled(true),
     m_visible(true),
-    m_tag(0),
-    m_menuBar(0),
-    m_containingMenuItem(0)
+    m_tag(0)
 {
     QMacAutoReleasePool pool;
 
-    m_delegate = [[QCocoaMenuDelegate alloc] initWithMenu:this];
-    m_nativeItem = [[NSMenuItem alloc] initWithTitle:@"" action:nil keyEquivalent:@""];
     m_nativeMenu = [[NSMenu alloc] initWithTitle:@"Untitled"];
     [m_nativeMenu setAutoenablesItems:YES];
-    m_nativeMenu.delegate = (QCocoaMenuDelegate *) m_delegate;
-    [m_nativeItem setSubmenu:m_nativeMenu];
+    m_nativeMenu.delegate = [[QCocoaMenuDelegate alloc] initWithMenu:this];
 }
 
 QCocoaMenu::~QCocoaMenu()
@@ -257,14 +275,11 @@ QCocoaMenu::~QCocoaMenu()
             SET_COCOA_MENU_ANCESTOR(item, 0);
     }
 
-    if (m_containingMenuItem)
-        m_containingMenuItem->clearMenu(this);
-
     QMacAutoReleasePool pool;
-    [m_nativeItem setSubmenu:nil];
+    NSObject *delegate = m_nativeMenu.delegate;
+    m_nativeMenu.delegate = nil;
+    [delegate release];
     [m_nativeMenu release];
-    [m_delegate release];
-    [m_nativeItem release];
 }
 
 void QCocoaMenu::setText(const QString &text)
@@ -272,7 +287,6 @@ void QCocoaMenu::setText(const QString &text)
     QMacAutoReleasePool pool;
     QString stripped = qt_mac_removeAmpersandEscapes(text);
     [m_nativeMenu setTitle:QCFString::toNSString(stripped)];
-    [m_nativeItem setTitle:QCFString::toNSString(stripped)];
 }
 
 void QCocoaMenu::setMinimumWidth(int width)
@@ -313,17 +327,13 @@ void QCocoaMenu::insertMenuItem(QPlatformMenuItem *menuItem, QPlatformMenuItem *
 
 void QCocoaMenu::insertNative(QCocoaMenuItem *item, QCocoaMenuItem *beforeItem)
 {
-    [item->nsItem() setTarget:m_delegate];
+    item->nsItem().target = m_nativeMenu.delegate;
     if (!item->menu())
         [item->nsItem() setAction:@selector(itemFired:)];
 
     if (item->isMerged())
         return;
 
-    if ([item->nsItem() menu]) {
-        qWarning("Menu item is already in a menu, remove it from the other menu first before inserting");
-        return;
-    }
     // if the item we're inserting before is merged, skip along until
     // we find a non-merged real item to insert ahead of.
     while (beforeItem && beforeItem->isMerged()) {
@@ -451,12 +461,11 @@ void QCocoaMenu::setEnabled(bool enabled)
 
 bool QCocoaMenu::isEnabled() const
 {
-    return [m_nativeItem isEnabled];
+    return m_attachedItem ? [m_attachedItem isEnabled] : m_enabled;
 }
 
 void QCocoaMenu::setVisible(bool visible)
 {
-    [m_nativeItem setSubmenu:(visible ? m_nativeMenu : nil)];
     m_visible = visible;
 }
 
@@ -593,8 +602,6 @@ void QCocoaMenu::syncModalState(bool modal)
     if (!m_enabled)
         modal = true;
 
-    [m_nativeItem setEnabled:!modal];
-
     foreach (QCocoaMenuItem *item, m_menuItems) {
         if (item->menu()) { // recurse into submenus
             item->menu()->syncModalState(modal);
@@ -605,25 +612,24 @@ void QCocoaMenu::syncModalState(bool modal)
     }
 }
 
-void QCocoaMenu::setMenuBar(QCocoaMenuBar *menuBar)
+void QCocoaMenu::setAttachedItem(NSMenuItem *item)
 {
-    m_menuBar = menuBar;
-    SET_COCOA_MENU_ANCESTOR(this, menuBar);
+    if (item == m_attachedItem)
+        return;
+
+    if (m_attachedItem)
+        m_attachedItem.submenu = nil;
+
+    m_attachedItem = item;
+
+    if (m_attachedItem)
+        m_attachedItem.submenu = m_nativeMenu;
+
 }
 
-QCocoaMenuBar *QCocoaMenu::menuBar() const
+NSMenuItem *QCocoaMenu::attachedItem() const
 {
-    return m_menuBar;
-}
-
-void QCocoaMenu::setContainingMenuItem(QCocoaMenuItem *menuItem)
-{
-    m_containingMenuItem = menuItem;
-}
-
-QCocoaMenuItem *QCocoaMenu::containingMenuItem() const
-{
-    return m_containingMenuItem;
+    return m_attachedItem;
 }
 
 QT_END_NAMESPACE
diff --git a/src/plugins/platforms/cocoa/qcocoamenubar.h b/src/plugins/platforms/cocoa/qcocoamenubar.h
index 0521bcd430b..7ce20594509 100644
--- a/src/plugins/platforms/cocoa/qcocoamenubar.h
+++ b/src/plugins/platforms/cocoa/qcocoamenubar.h
@@ -77,10 +77,10 @@ private:
     static QCocoaMenuBar *findGlobalMenubar();
 
     bool shouldDisable(QCocoaWindow *active) const;
-    void insertNativeMenu(QCocoaMenu *menu, QCocoaMenu *beforeMenu);
-    void removeNativeMenu(QCocoaMenu *menu);
 
-    QList<QCocoaMenu*> m_menus;
+    NSMenuItem *nativeItemForMenu(QCocoaMenu *menu) const;
+
+    QList<QPointer<QCocoaMenu> > m_menus;
     NSMenu *m_nativeMenu;
     QCocoaWindow *m_window;
 };
diff --git a/src/plugins/platforms/cocoa/qcocoamenubar.mm b/src/plugins/platforms/cocoa/qcocoamenubar.mm
index c9a42e9d8ee..e8b3823012a 100644
--- a/src/plugins/platforms/cocoa/qcocoamenubar.mm
+++ b/src/plugins/platforms/cocoa/qcocoamenubar.mm
@@ -57,7 +57,6 @@ static inline QCocoaMenuLoader *getMenuLoader()
     return [NSApp QT_MANGLE_NAMESPACE(qt_qcocoamenuLoader)];
 }
 
-
 QCocoaMenuBar::QCocoaMenuBar() :
     m_window(0)
 {
@@ -74,11 +73,20 @@ QCocoaMenuBar::~QCocoaMenuBar()
 #ifdef QT_COCOA_ENABLE_MENU_DEBUG
     qDebug() << "~QCocoaMenuBar" << this;
 #endif
+    foreach (QCocoaMenu *menu, m_menus) {
+        if (!menu)
+            continue;
+        NSMenuItem *item = nativeItemForMenu(menu);
+        if (menu->attachedItem() == item)
+            menu->setAttachedItem(nil);
+    }
+
     [m_nativeMenu release];
     static_menubars.removeOne(this);
 
     if (m_window && m_window->menubar() == this) {
         m_window->setMenubar(0);
+
         // Delete the children first so they do not cause
         // the native menu items to be hidden after
         // the menu bar was updated
@@ -87,24 +95,6 @@ QCocoaMenuBar::~QCocoaMenuBar()
     }
 }
 
-void QCocoaMenuBar::insertNativeMenu(QCocoaMenu *menu, QCocoaMenu *beforeMenu)
-{
-    QMacAutoReleasePool pool;
-
-    if (beforeMenu) {
-        NSUInteger nativeIndex = [m_nativeMenu indexOfItem:beforeMenu->nsMenuItem()];
-        [m_nativeMenu insertItem: menu->nsMenuItem() atIndex: nativeIndex];
-    } else {
-        [m_nativeMenu addItem: menu->nsMenuItem()];
-    }
-
-    menu->setMenuBar(this);
-    syncMenu(static_cast<QPlatformMenu *>(menu));
-    if (menu->isVisible()) {
-        [m_nativeMenu setSubmenu: menu->nsMenu() forItem: menu->nsMenuItem()];
-    }
-}
-
 void QCocoaMenuBar::insertMenu(QPlatformMenu *platformMenu, QPlatformMenu *before)
 {
     QCocoaMenu *menu = static_cast<QCocoaMenu *>(platformMenu);
@@ -113,33 +103,42 @@ void QCocoaMenuBar::insertMenu(QPlatformMenu *platformMenu, QPlatformMenu *befor
     qDebug() << "QCocoaMenuBar" << this << "insertMenu" << menu << "before" << before;
 #endif
 
-    if (m_menus.contains(menu)) {
+    if (m_menus.contains(QPointer<QCocoaMenu>(menu))) {
         qWarning("This menu already belongs to the menubar, remove it first");
         return;
     }
 
-    if (beforeMenu && !m_menus.contains(beforeMenu)) {
+    if (beforeMenu && !m_menus.contains(QPointer<QCocoaMenu>(beforeMenu))) {
         qWarning("The before menu does not belong to the menubar");
         return;
     }
 
-    m_menus.insert(beforeMenu ? m_menus.indexOf(beforeMenu) : m_menus.size(), menu);
-    if (!menu->menuBar())
-        insertNativeMenu(menu, beforeMenu);
+    int insertionIndex = beforeMenu ? m_menus.indexOf(beforeMenu) : m_menus.size();
+    m_menus.insert(insertionIndex, menu);
+
+    {
+        QMacAutoReleasePool pool;
+        NSMenuItem *item = [[[NSMenuItem alloc] init] autorelease];
+        item.tag = reinterpret_cast<NSInteger>(menu);
+
+        if (beforeMenu) {
+            // QMenuBar::toNSMenu() exposes the native menubar and
+            // the user could have inserted its own items in there.
+            // Same remark applies to removeMenu().
+            NSMenuItem *beforeItem = nativeItemForMenu(beforeMenu);
+            NSInteger nativeIndex = [m_nativeMenu indexOfItem:beforeItem];
+            [m_nativeMenu insertItem:item atIndex:nativeIndex];
+        } else {
+            [m_nativeMenu addItem:item];
+        }
+    }
+
+    syncMenu(menu);
+
     if (m_window && m_window->window()->isActive())
         updateMenuBarImmediately();
 }
 
-void QCocoaMenuBar::removeNativeMenu(QCocoaMenu *menu)
-{
-    QMacAutoReleasePool pool;
-
-    if (menu->menuBar() == this)
-        menu->setMenuBar(0);
-    NSUInteger realIndex = [m_nativeMenu indexOfItem:menu->nsMenuItem()];
-    [m_nativeMenu removeItemAtIndex: realIndex];
-}
-
 void QCocoaMenuBar::removeMenu(QPlatformMenu *platformMenu)
 {
     QCocoaMenu *menu = static_cast<QCocoaMenu *>(platformMenu);
@@ -147,8 +146,17 @@ void QCocoaMenuBar::removeMenu(QPlatformMenu *platformMenu)
         qWarning("Trying to remove a menu that does not belong to the menubar");
         return;
     }
+
+    NSMenuItem *item = nativeItemForMenu(menu);
+    if (menu->attachedItem() == item)
+        menu->setAttachedItem(nil);
     m_menus.removeOne(menu);
-    removeNativeMenu(menu);
+
+    QMacAutoReleasePool pool;
+
+    // See remark in insertMenu().
+    NSInteger nativeIndex = [m_nativeMenu indexOfItem:item];
+    [m_nativeMenu removeItemAtIndex:nativeIndex];
 }
 
 void QCocoaMenuBar::syncMenu(QPlatformMenu *menu)
@@ -170,7 +178,16 @@ void QCocoaMenuBar::syncMenu(QPlatformMenu *menu)
                 break;
             }
     }
-    [cocoaMenu->nsMenuItem() setHidden:shouldHide];
+
+    nativeItemForMenu(cocoaMenu).hidden = shouldHide;
+}
+
+NSMenuItem *QCocoaMenuBar::nativeItemForMenu(QCocoaMenu *menu) const
+{
+    if (!menu)
+        return nil;
+
+    return [m_nativeMenu itemWithTag:reinterpret_cast<NSInteger>(menu)];
 }
 
 void QCocoaMenuBar::handleReparent(QWindow *newParentWindow)
@@ -297,24 +314,16 @@ void QCocoaMenuBar::updateMenuBarImmediately()
     qDebug() << "QCocoaMenuBar" << "updateMenuBarImmediately" << cw;
 #endif
     bool disableForModal = mb->shouldDisable(cw);
-    // force a sync?
-    foreach (QCocoaMenu *m, mb->m_menus) {
-        mb->syncMenu(m);
-        m->syncModalState(disableForModal);
-    }
 
-    // reparent shared menu items if necessary.
-    // We browse the list in reverse order to be sure that the next items are redrawn before the current ones,
-    // in this way we are sure that "beforeMenu" (see below) is part of the native menu before "m" is redraw
-    for (int i = mb->m_menus.size() - 1; i >= 0; i--) {
-        QCocoaMenu *m = mb->m_menus.at(i);
-        QCocoaMenuBar *menuBar = m->menuBar();
-        if (menuBar != mb) {
-            QCocoaMenu *beforeMenu  = i < (mb->m_menus.size() - 1) ? mb->m_menus.at(i + 1) : 0;
-            if (menuBar)
-                menuBar->removeNativeMenu(m);
-            mb->insertNativeMenu(m, beforeMenu);
-        }
+    foreach (QCocoaMenu *menu, mb->m_menus) {
+        if (!menu)
+            continue;
+        NSMenuItem *item = mb->nativeItemForMenu(menu);
+        menu->setAttachedItem(item);
+        SET_COCOA_MENU_ANCESTOR(menu, mb);
+        // force a sync?
+        mb->syncMenu(menu);
+        menu->syncModalState(disableForModal);
     }
 
     QCocoaMenuLoader *loader = getMenuLoader();
diff --git a/src/plugins/platforms/cocoa/qcocoamenuitem.h b/src/plugins/platforms/cocoa/qcocoamenuitem.h
index 0d6f67959bd..bba9ce3963a 100644
--- a/src/plugins/platforms/cocoa/qcocoamenuitem.h
+++ b/src/plugins/platforms/cocoa/qcocoamenuitem.h
@@ -93,7 +93,6 @@ public:
     inline bool isSeparator() const { return m_isSeparator; }
 
     QCocoaMenu *menu() const { return m_menu; }
-    void clearMenu(QCocoaMenu *menu);
     MenuRole effectiveRole() const;
 
 private:
@@ -105,7 +104,7 @@ private:
     QString m_text;
     bool m_textSynced;
     QIcon m_icon;
-    QCocoaMenu *m_menu;
+    QPointer<QCocoaMenu> m_menu;
     bool m_isVisible;
     bool m_enabled;
     bool m_isSeparator;
diff --git a/src/plugins/platforms/cocoa/qcocoamenuitem.mm b/src/plugins/platforms/cocoa/qcocoamenuitem.mm
index 9e4f0b9ad1c..de0271ce4dc 100644
--- a/src/plugins/platforms/cocoa/qcocoamenuitem.mm
+++ b/src/plugins/platforms/cocoa/qcocoamenuitem.mm
@@ -142,15 +142,12 @@ void QCocoaMenuItem::setMenu(QPlatformMenu *menu)
     if (m_menu) {
         if (COCOA_MENU_ANCESTOR(m_menu) == this)
             SET_COCOA_MENU_ANCESTOR(m_menu, 0);
-        if (m_menu->containingMenuItem() == this)
-            m_menu->setContainingMenuItem(0);
     }
 
     QMacAutoReleasePool pool;
     m_menu = static_cast<QCocoaMenu *>(menu);
     if (m_menu) {
         SET_COCOA_MENU_ANCESTOR(m_menu, this);
-        m_menu->setContainingMenuItem(this);
     } else {
         // we previously had a menu, but no longer
         // clear out our item so the nexy sync() call builds a new one
@@ -159,12 +156,6 @@ void QCocoaMenuItem::setMenu(QPlatformMenu *menu)
     }
 }
 
-void QCocoaMenuItem::clearMenu(QCocoaMenu *menu)
-{
-    if (menu == m_menu)
-        m_menu = 0;
-}
-
 void QCocoaMenuItem::setVisible(bool isVisible)
 {
     m_isVisible = isVisible;
@@ -226,14 +217,6 @@ NSMenuItem *QCocoaMenuItem::sync()
             m_native = nil;
     }
 
-    if (m_menu) {
-        if (m_native != m_menu->nsMenuItem()) {
-            [m_native release];
-            m_native = [m_menu->nsMenuItem() retain];
-            [m_native setTag:reinterpret_cast<NSInteger>(this)];
-        }
-    }
-
     if ((m_role != NoRole && !m_textSynced) || m_merged) {
         NSMenuItem *mergeItem = nil;
         QCocoaMenuLoader *loader = getMenuLoader();
diff --git a/src/plugins/platforms/cocoa/qcocoasystemsettings.mm b/src/plugins/platforms/cocoa/qcocoasystemsettings.mm
index 7fd55372150..be5fa61b8be 100644
--- a/src/plugins/platforms/cocoa/qcocoasystemsettings.mm
+++ b/src/plugins/platforms/cocoa/qcocoasystemsettings.mm
@@ -153,6 +153,7 @@ static QMacPaletteMap mac_widget_colors[] = {
     QMacPaletteMap(QPlatformTheme::LabelPalette, kThemeTextColorPlacardActive, kThemeTextColorPlacardInactive),
     QMacPaletteMap(QPlatformTheme::GroupBoxPalette, kThemeTextColorPlacardActive, kThemeTextColorPlacardInactive),
     QMacPaletteMap(QPlatformTheme::MenuPalette, kThemeTextColorMenuItemActive, kThemeTextColorMenuItemDisabled),
+    QMacPaletteMap(QPlatformTheme::MenuBarPalette, kThemeTextColorMenuItemActive, kThemeTextColorMenuItemDisabled),
     //### TODO: The zeros below gives white-on-black text.
     QMacPaletteMap(QPlatformTheme::TextEditPalette, 0, 0),
     QMacPaletteMap(QPlatformTheme::TextLineEditPalette, 0, 0),
@@ -177,7 +178,8 @@ QHash<QPlatformTheme::Palette, QPalette*> qt_mac_createRolePalettes()
             pal.setColor(QPalette::Disabled, QPalette::WindowText, qc);
             pal.setColor(QPalette::Disabled, QPalette::HighlightedText, qc);
         }
-        if (mac_widget_colors[i].paletteRole == QPlatformTheme::MenuPalette) {
+        if (mac_widget_colors[i].paletteRole == QPlatformTheme::MenuPalette
+                || mac_widget_colors[i].paletteRole == QPlatformTheme::MenuBarPalette) {
             pal.setBrush(QPalette::Background, qt_mac_brushForTheme(kThemeBrushMenuBackground));
             qc = qt_mac_colorForThemeTextColor(kThemeTextColorMenuItemActive);
             pal.setBrush(QPalette::ButtonText, qc);
diff --git a/src/plugins/platforms/cocoa/qcocoawindow.mm b/src/plugins/platforms/cocoa/qcocoawindow.mm
index 9572b5ac4ca..01e72303be4 100644
--- a/src/plugins/platforms/cocoa/qcocoawindow.mm
+++ b/src/plugins/platforms/cocoa/qcocoawindow.mm
@@ -376,9 +376,8 @@ QCocoaWindow::QCocoaWindow(QWindow *tlw)
     , m_bottomContentBorderThickness(0)
     , m_normalGeometry(QRect(0,0,-1,-1))
 {
-#ifdef QT_COCOA_ENABLE_WINDOW_DEBUG
-    qDebug() << "QCocoaWindow::QCocoaWindow" << this;
-#endif
+    qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::QCocoaWindow" << window();
+
     QMacAutoReleasePool pool;
 
     if (tlw->type() == Qt::ForeignWindow) {
@@ -411,11 +410,10 @@ QCocoaWindow::QCocoaWindow(QWindow *tlw)
 
 QCocoaWindow::~QCocoaWindow()
 {
-#ifdef QT_COCOA_ENABLE_WINDOW_DEBUG
-    qDebug() << "QCocoaWindow::~QCocoaWindow" << this;
-#endif
+    qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::~QCocoaWindow" << window();
 
     QMacAutoReleasePool pool;
+    [m_nsWindow makeFirstResponder:nil];
     [m_nsWindow setContentView:nil];
     [m_nsWindow.helper detachFromPlatformWindow];
     if (m_isNSWindowChild) {
@@ -470,6 +468,8 @@ QSurfaceFormat QCocoaWindow::format() const
 
 void QCocoaWindow::setGeometry(const QRect &rectIn)
 {
+    qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::setGeometry" << window() << rectIn;
+
     QBoolBlocker inSetGeometry(m_inSetGeometry, true);
 
     QRect rect = rectIn;
@@ -482,9 +482,7 @@ void QCocoaWindow::setGeometry(const QRect &rectIn)
     }
     if (geometry() == rect)
         return;
-#ifdef QT_COCOA_ENABLE_WINDOW_DEBUG
-    qDebug() << "QCocoaWindow::setGeometry" << this << rect;
-#endif
+
     setCocoaGeometry(rect);
 }
 
@@ -507,6 +505,7 @@ QRect QCocoaWindow::geometry() const
 
 void QCocoaWindow::setCocoaGeometry(const QRect &rect)
 {
+    qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::setCocoaGeometry" << window() << rect;
     QMacAutoReleasePool pool;
 
     if (m_contentViewIsEmbedded) {
@@ -630,6 +629,8 @@ void QCocoaWindow::show(bool becauseOfAncestor)
 
 void QCocoaWindow::setVisible(bool visible)
 {
+    qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::setVisible" << window() << visible;
+
     if (m_isNSWindowChild && m_hiddenByClipping)
         return;
 
@@ -639,9 +640,7 @@ void QCocoaWindow::setVisible(bool visible)
     QCocoaWindow *parentCocoaWindow = 0;
     if (window()->transientParent())
         parentCocoaWindow = static_cast<QCocoaWindow *>(window()->transientParent()->handle());
-#ifdef QT_COCOA_ENABLE_WINDOW_DEBUG
-    qDebug() << "QCocoaWindow::setVisible" << window() << visible;
-#endif
+
     if (visible) {
         // We need to recreate if the modality has changed as the style mask will need updating
         if (m_windowModality != window()->modality())
@@ -862,9 +861,6 @@ NSUInteger QCocoaWindow::windowStyleMask(Qt::WindowFlags flags)
     if (m_drawContentBorderGradient)
         styleMask |= NSTexturedBackgroundWindowMask;
 
-#ifdef QT_COCOA_ENABLE_WINDOW_DEBUG
-    qDebug("windowStyleMask of '%s': flags %X -> styleMask %lX", qPrintable(window()->title()), (int)flags, styleMask);
-#endif
     return styleMask;
 }
 
@@ -986,7 +982,8 @@ bool QCocoaWindow::isAlertState() const
 
 void QCocoaWindow::raise()
 {
-    //qDebug() << "raise" << this;
+    qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::raise" << window();
+
     // ### handle spaces (see Qt 4 raise_sys in qwidget_mac.mm)
     if (!m_nsWindow)
         return;
@@ -1006,7 +1003,15 @@ void QCocoaWindow::raise()
             [parentNSWindow removeChildWindow:m_nsWindow];
             [parentNSWindow addChildWindow:m_nsWindow ordered:NSWindowAbove];
         } else {
-            [m_nsWindow orderFront: m_nsWindow];
+            {
+                // Clean up autoreleased temp objects from orderFront immediately.
+                // Failure to do so has been observed to cause leaks also beyond any outer
+                // autorelease pool (for example around a complete QWindow
+                // construct-show-raise-hide-delete cyle), counter to expected autoreleasepool
+                // behavior.
+                QMacAutoReleasePool pool;
+                [m_nsWindow orderFront: m_nsWindow];
+            }
             static bool raiseProcess = qt_mac_resolveOption(true, "QT_MAC_SET_RAISE_PROCESS");
             if (raiseProcess) {
                 ProcessSerialNumber psn;
@@ -1019,6 +1024,7 @@ void QCocoaWindow::raise()
 
 void QCocoaWindow::lower()
 {
+    qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::lower" << window();
     if (!m_nsWindow)
         return;
     if (m_isNSWindowChild) {
@@ -1071,13 +1077,11 @@ void QCocoaWindow::propagateSizeHints()
     if (!m_nsWindow)
         return;
 
-#ifdef QT_COCOA_ENABLE_WINDOW_DEBUG
-    qDebug() << "QCocoaWindow::propagateSizeHints" << this;
-    qDebug() << "       min/max" << windowMinimumSize() << windowMaximumSize();
-    qDebug() << "size increment" << windowSizeIncrement();
-    qDebug() << "      basesize" << windowBaseSize();
-    qDebug() << "      geometry" << windowGeometry();
-#endif
+    qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::propagateSizeHints" << window() << "\n"
+                              << "       min/max" << windowMinimumSize() << windowMaximumSize()
+                              << "size increment" << windowSizeIncrement()
+                              << "      basesize" << windowBaseSize()
+                              << "      geometry" << windowGeometry();
 
     // Set the minimum content size.
     const QSize minimumSize = windowMinimumSize();
@@ -1109,6 +1113,7 @@ void QCocoaWindow::propagateSizeHints()
 
 void QCocoaWindow::setOpacity(qreal level)
 {
+    qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::setOpacity" << level;
     if (m_nsWindow) {
         [m_nsWindow setAlphaValue:level];
         [m_nsWindow setOpaque: isOpaque()];
@@ -1117,6 +1122,7 @@ void QCocoaWindow::setOpacity(qreal level)
 
 void QCocoaWindow::setMask(const QRegion &region)
 {
+    qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::setMask" << window() << region;
     if (m_nsWindow)
         [m_nsWindow setBackgroundColor:[NSColor clearColor]];
 
@@ -1126,6 +1132,7 @@ void QCocoaWindow::setMask(const QRegion &region)
 
 bool QCocoaWindow::setKeyboardGrabEnabled(bool grab)
 {
+    qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::setKeyboardGrabEnabled" << window() << grab;
     if (!m_nsWindow)
         return false;
 
@@ -1138,6 +1145,7 @@ bool QCocoaWindow::setKeyboardGrabEnabled(bool grab)
 
 bool QCocoaWindow::setMouseGrabEnabled(bool grab)
 {
+    qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::setMouseGrabEnabled" << window() << grab;
     if (!m_nsWindow)
         return false;
 
@@ -1155,6 +1163,8 @@ WId QCocoaWindow::winId() const
 
 void QCocoaWindow::setParent(const QPlatformWindow *parentWindow)
 {
+    qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::setParent" << window() << (parentWindow ? parentWindow->window() : 0);
+
     // recreate the window for compatibility
     bool unhideAfterRecreate = parentWindow && !m_contentViewIsToBeEmbedded && ![m_contentView isHidden];
     recreateWindow(parentWindow);
@@ -1238,6 +1248,7 @@ void QCocoaWindow::windowDidEndLiveResize()
 
 bool QCocoaWindow::windowShouldClose()
 {
+    qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::windowShouldClose" << window();
    // This callback should technically only determine if the window
    // should (be allowed to) close, but since our QPA API to determine
    // that also involves actually closing the window we do both at the
@@ -1278,6 +1289,9 @@ QCocoaGLContext *QCocoaWindow::currentContext() const
 
 void QCocoaWindow::recreateWindow(const QPlatformWindow *parentWindow)
 {
+    qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::recreateWindow" << window()
+                              << "parent" << (parentWindow ? parentWindow->window() : 0);
+
     bool wasNSWindowChild = m_isNSWindowChild;
     BOOL requestNSWindowChild = qt_mac_resolveOption(NO, window(), "_q_platform_MacUseNSWindow",
                                                                    "QT_MAC_USE_NSWINDOW");
@@ -1614,10 +1628,6 @@ void QCocoaWindow::syncWindowState(Qt::WindowState newState)
         }
     }
 
-#ifdef QT_COCOA_ENABLE_WINDOW_DEBUG
-    qDebug() << "QCocoaWindow::syncWindowState" << newState << "actual" << predictedState << "was" << m_synchedWindowState << "effectively maximized" << m_effectivelyMaximized;
-#endif
-
     // New state is now the current synched state
     m_synchedWindowState = predictedState;
 }
@@ -1810,7 +1820,9 @@ void QCocoaWindow::exposeWindow()
         m_isExposed = true;
         m_exposedGeometry = geometry();
         m_exposedDevicePixelRatio = devicePixelRatio();
-        QWindowSystemInterface::handleExposeEvent(window(), QRect(QPoint(0, 0), m_exposedGeometry.size()));
+        QRect geometry(QPoint(0, 0), m_exposedGeometry.size());
+        qCDebug(lcQpaCocoaWindow) << "QCocoaWindow: exposeWindow" << window() << geometry;
+        QWindowSystemInterface::handleExposeEvent(window(), geometry);
     }
 }
 
@@ -1820,6 +1832,8 @@ void QCocoaWindow::obscureWindow()
     if (m_isExposed) {
         m_geometryUpdateExposeAllowed = false;
         m_isExposed = false;
+
+        qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::obscureWindow" << window();
         QWindowSystemInterface::handleExposeEvent(window(), QRegion());
     }
 }
@@ -1846,7 +1860,10 @@ void QCocoaWindow::updateExposedGeometry()
     m_isExposed = true;
     m_exposedGeometry = geometry();
     m_exposedDevicePixelRatio = devicePixelRatio();
-    QWindowSystemInterface::handleExposeEvent(window(), QRect(QPoint(0, 0), m_exposedGeometry.size()));
+
+    QRect geometry(QPoint(0, 0), m_exposedGeometry.size());
+    qCDebug(lcQpaCocoaWindow) << "QCocoaWindow::updateExposedGeometry" << window() << geometry;
+    QWindowSystemInterface::handleExposeEvent(window(), geometry);
 }
 
 QWindow *QCocoaWindow::childWindowAt(QPoint windowPoint)
diff --git a/src/plugins/platforms/cocoa/qnsview.h b/src/plugins/platforms/cocoa/qnsview.h
index cbd92df9cfd..b5738abf4c7 100644
--- a/src/plugins/platforms/cocoa/qnsview.h
+++ b/src/plugins/platforms/cocoa/qnsview.h
@@ -43,6 +43,7 @@
 #include <AppKit/AppKit.h>
 
 #include <QtCore/QPointer>
+#include <QtCore/QSet>
 #include <QtGui/QImage>
 #include <QtGui/QAccessible>
 
@@ -59,6 +60,7 @@ Q_FORWARD_DECLARE_OBJC_CLASS(QT_MANGLE_NAMESPACE(QNSViewMouseMoveHelper));
 @interface QT_MANGLE_NAMESPACE(QNSView) : NSView <NSTextInputClient> {
     QCocoaBackingStore* m_backingStore;
     QPoint m_backingStoreOffset;
+    QRegion m_maskRegion;
     CGImageRef m_maskImage;
     uchar *m_maskData;
     bool m_shouldInvalidateWindowShadow;
@@ -66,6 +68,7 @@ Q_FORWARD_DECLARE_OBJC_CLASS(QT_MANGLE_NAMESPACE(QNSViewMouseMoveHelper));
     QCocoaWindow *m_platformWindow;
     NSTrackingArea *m_trackingArea;
     Qt::MouseButtons m_buttons;
+    Qt::MouseButtons m_acceptedMouseDowns;
     Qt::MouseButtons m_frameStrutButtons;
     QString m_composingText;
     bool m_sendKeyEvent;
@@ -85,6 +88,7 @@ Q_FORWARD_DECLARE_OBJC_CLASS(QT_MANGLE_NAMESPACE(QNSViewMouseMoveHelper));
     bool m_exposedOnMoveToWindow;
     NSEvent *m_currentlyInterpretedKeyEvent;
     bool m_isMenuView;
+    QSet<quint32> m_acceptedKeyDowns;
 }
 
 - (id)init;
@@ -118,6 +122,9 @@ Q_FORWARD_DECLARE_OBJC_CLASS(QT_MANGLE_NAMESPACE(QNSViewMouseMoveHelper));
 - (void)resetMouseButtons;
 
 - (void)handleMouseEvent:(NSEvent *)theEvent;
+- (bool)handleMouseDownEvent:(NSEvent *)theEvent;
+- (bool)handleMouseDraggedEvent:(NSEvent *)theEvent;
+- (bool)handleMouseUpEvent:(NSEvent *)theEvent;
 - (void)mouseDown:(NSEvent *)theEvent;
 - (void)mouseDragged:(NSEvent *)theEvent;
 - (void)mouseUp:(NSEvent *)theEvent;
@@ -139,7 +146,7 @@ Q_FORWARD_DECLARE_OBJC_CLASS(QT_MANGLE_NAMESPACE(QNSViewMouseMoveHelper));
 
 - (int) convertKeyCode : (QChar)keyCode;
 + (Qt::KeyboardModifiers) convertKeyModifiers : (ulong)modifierFlags;
-- (void)handleKeyEvent:(NSEvent *)theEvent eventType:(int)eventType;
+- (bool)handleKeyEvent:(NSEvent *)theEvent eventType:(int)eventType;
 - (void)keyDown:(NSEvent *)theEvent;
 - (void)keyUp:(NSEvent *)theEvent;
 
diff --git a/src/plugins/platforms/cocoa/qnsview.mm b/src/plugins/platforms/cocoa/qnsview.mm
index 360ad3baf7d..bb12c30fa3b 100644
--- a/src/plugins/platforms/cocoa/qnsview.mm
+++ b/src/plugins/platforms/cocoa/qnsview.mm
@@ -145,6 +145,7 @@ static NSString *_q_NSWindowDidChangeOcclusionStateNotification = nil;
         m_shouldInvalidateWindowShadow = false;
         m_window = 0;
         m_buttons = Qt::NoButton;
+        m_acceptedMouseDowns = Qt::NoButton;
         m_frameStrutButtons = Qt::NoButton;
         m_sendKeyEvent = false;
         m_subscribesForGlobalFrameNotifications = false;
@@ -361,15 +362,16 @@ static NSString *_q_NSWindowDidChangeOcclusionStateNotification = nil;
     if (m_platformWindow->m_nsWindow && geometry == m_platformWindow->geometry())
         return;
 
+    const bool isResize = geometry.size() != m_platformWindow->geometry().size();
+
     // It can happen that self.window is nil (if we are changing
     // styleMask from/to borderless and content view is being re-parented)
     // - this results in an invalid coordinates.
     if (m_platformWindow->m_inSetStyleMask && !self.window)
         return;
 
-#ifdef QT_COCOA_ENABLE_WINDOW_DEBUG
-    qDebug() << "QNSView::udpateGeometry" << m_platformWindow << geometry;
-#endif
+     qCDebug(lcQpaCocoaWindow) << "[QNSView udpateGeometry:]" << m_window
+                               << "current" << m_platformWindow->geometry() << "new" << geometry;
 
     // Call setGeometry on QPlatformWindow. (not on QCocoaWindow,
     // doing that will initiate a geometry change it and possibly create
@@ -390,7 +392,7 @@ static NSString *_q_NSWindowDidChangeOcclusionStateNotification = nil;
         // calles, which Qt and Qt applications do not excpect.
         if (!m_platformWindow->m_inSetGeometry)
             QWindowSystemInterface::flushWindowSystemEvents();
-        else
+        else if (isResize)
             m_backingStore = 0;
     }
 }
@@ -512,6 +514,8 @@ QT_WARNING_POP
 
 - (void) flushBackingStore:(QCocoaBackingStore *)backingStore region:(const QRegion &)region offset:(QPoint)offset
 {
+    qCDebug(lcQpaCocoaWindow) << "[QNSView flushBackingStore:]" << m_window << region.rectCount() << region.boundingRect() << offset;
+
     m_backingStore = backingStore;
     m_backingStoreOffset = offset * m_backingStore->getBackingStoreDevicePixelRatio();
     for (const QRect &rect : region)
@@ -526,7 +530,7 @@ QT_WARNING_POP
 
 - (BOOL) hasMask
 {
-    return m_maskImage != 0;
+    return !m_maskRegion.isEmpty();
 }
 
 - (BOOL) isOpaque
@@ -539,6 +543,7 @@ QT_WARNING_POP
 - (void) setMaskRegion:(const QRegion *)region
 {
     m_shouldInvalidateWindowShadow = true;
+    m_maskRegion = *region;
     if (m_maskImage)
         CGImageRelease(m_maskImage);
     if (region->isEmpty()) {
@@ -574,6 +579,8 @@ QT_WARNING_POP
 
 - (void) drawRect:(NSRect)dirtyRect
 {
+    qCDebug(lcQpaCocoaWindow) << "[QNSView drawRect:]" << m_window << qt_mac_toQRect(dirtyRect);
+
 #ifndef QT_NO_OPENGL
     if (m_glContext && m_shouldSetGLContextinDrawRect) {
         [m_glContext->nsOpenGLContext() setView:self];
@@ -813,6 +820,82 @@ QT_WARNING_POP
     QWindowSystemInterface::handleFrameStrutMouseEvent(m_window, timestamp, qtWindowPoint, qtScreenPoint, m_frameStrutButtons);
 }
 
+- (bool)handleMouseDownEvent:(NSEvent *)theEvent
+{
+    if (m_window && (m_window->flags() & Qt::WindowTransparentForInput))
+        return false;
+
+    Qt::MouseButton button = cocoaButton2QtButton([theEvent buttonNumber]);
+
+    QPointF qtWindowPoint;
+    QPointF qtScreenPoint;
+    [self convertFromScreen:[self screenMousePoint:theEvent] toWindowPoint:&qtWindowPoint andScreenPoint:&qtScreenPoint];
+    Q_UNUSED(qtScreenPoint);
+
+    // Maintain masked state for the button for use by MouseDragged and MouseUp.
+    const bool masked = m_maskRegion.contains(qtWindowPoint.toPoint());
+    if (masked)
+        m_acceptedMouseDowns &= ~button;
+    else
+        m_acceptedMouseDowns |= button;
+
+    // Forward masked out events to the next responder
+    if (masked)
+        return false;
+
+    if (button == Qt::RightButton)
+        m_sendUpAsRightButton = true;
+
+    m_buttons |= button;
+
+    [self handleMouseEvent:theEvent];
+    return true;
+}
+
+- (bool)handleMouseDraggedEvent:(NSEvent *)theEvent
+{
+    if (m_window && (m_window->flags() & Qt::WindowTransparentForInput))
+        return false;
+
+    Qt::MouseButton button = cocoaButton2QtButton([theEvent buttonNumber]);
+
+    // Forward the event to the next responder if Qt did not accept the
+    // corresponding mouse down for this button
+    if (!(m_acceptedMouseDowns & button) == button)
+        return false;
+
+    if (!(m_buttons & (m_sendUpAsRightButton ? Qt::RightButton : Qt::LeftButton))) {
+        qCWarning(lcQpaCocoaWindow) << "QNSView mouseDragged: Internal mouse button tracking"
+                                    << "invalid (missing Qt::LeftButton)";
+    }
+
+    [self handleMouseEvent:theEvent];
+    return true;
+}
+
+- (bool)handleMouseUpEvent:(NSEvent *)theEvent
+{
+    if (m_window && (m_window->flags() & Qt::WindowTransparentForInput))
+        return false;
+
+    Qt::MouseButton button = cocoaButton2QtButton([theEvent buttonNumber]);
+
+    // Forward the event to the next responder if Qt did not accept the
+    // corresponding mouse down for this button
+    if (!(m_acceptedMouseDowns & button) == button)
+        return false;
+
+    if (m_sendUpAsRightButton && button == Qt::LeftButton)
+        button = Qt::RightButton;
+    if (button == Qt::RightButton)
+        m_sendUpAsRightButton = false;
+
+    m_buttons &= ~button;
+
+    [self handleMouseEvent:theEvent];
+    return true;
+}
+
 - (void)mouseDown:(NSEvent *)theEvent
 {
     if (m_window && (m_window->flags() & Qt::WindowTransparentForInput) )
@@ -851,6 +934,25 @@ QT_WARNING_POP
         }
     }
 
+    QPointF qtWindowPoint;
+    QPointF qtScreenPoint;
+    [self convertFromScreen:[self screenMousePoint:theEvent] toWindowPoint:&qtWindowPoint andScreenPoint:&qtScreenPoint];
+    Q_UNUSED(qtScreenPoint);
+
+    bool masked = m_maskRegion.contains(qtWindowPoint.toPoint());
+
+    // Maintain masked state for the button for use by MouseDragged and Up.
+    if (masked)
+        m_acceptedMouseDowns &= ~Qt::LeftButton;
+    else
+        m_acceptedMouseDowns |= Qt::LeftButton;
+
+    // Forward masked out events to the next responder
+    if (masked) {
+        [super mouseDown:theEvent];
+        return;
+    }
+
     if ([self hasMarkedText]) {
         [[NSTextInputContext currentInputContext] handleEvent:theEvent];
     } else {
@@ -866,24 +968,58 @@ QT_WARNING_POP
 
 - (void)mouseDragged:(NSEvent *)theEvent
 {
-    if (m_window && (m_window->flags() & Qt::WindowTransparentForInput) )
-        return [super mouseDragged:theEvent];
-    if (!(m_buttons & (m_sendUpAsRightButton ? Qt::RightButton : Qt::LeftButton)))
-        qWarning("QNSView mouseDragged: Internal mouse button tracking invalid (missing Qt::LeftButton)");
-    [self handleMouseEvent:theEvent];
+    const bool accepted = [self handleMouseDraggedEvent:theEvent];
+    if (!accepted)
+        [super mouseDragged:theEvent];
 }
 
 - (void)mouseUp:(NSEvent *)theEvent
 {
-    if (m_window && (m_window->flags() & Qt::WindowTransparentForInput) )
-        return [super mouseUp:theEvent];
-    if (m_sendUpAsRightButton) {
-        m_buttons &= ~Qt::RightButton;
-        m_sendUpAsRightButton = false;
-    } else {
-        m_buttons &= ~Qt::LeftButton;
-    }
-    [self handleMouseEvent:theEvent];
+    const bool accepted = [self handleMouseUpEvent:theEvent];
+    if (!accepted)
+        [super mouseUp:theEvent];
+}
+
+- (void)rightMouseDown:(NSEvent *)theEvent
+{
+    const bool accepted = [self handleMouseDownEvent:theEvent];
+    if (!accepted)
+        [super rightMouseDown:theEvent];
+}
+
+- (void)rightMouseDragged:(NSEvent *)theEvent
+{
+    const bool accepted = [self handleMouseDraggedEvent:theEvent];
+    if (!accepted)
+        [super rightMouseDragged:theEvent];
+}
+
+- (void)rightMouseUp:(NSEvent *)theEvent
+{
+    const bool accepted = [self handleMouseUpEvent:theEvent];
+    if (!accepted)
+        [super rightMouseUp:theEvent];
+}
+
+- (void)otherMouseDown:(NSEvent *)theEvent
+{
+    const bool accepted = [self handleMouseDownEvent:theEvent];
+    if (!accepted)
+        [super otherMouseDown:theEvent];
+}
+
+- (void)otherMouseDragged:(NSEvent *)theEvent
+{
+    const bool accepted = [self handleMouseDraggedEvent:theEvent];
+    if (!accepted)
+        [super otherMouseDragged:theEvent];
+}
+
+- (void)otherMouseUp:(NSEvent *)theEvent
+{
+    const bool accepted = [self handleMouseUpEvent:theEvent];
+    if (!accepted)
+        [super otherMouseUp:theEvent];
 }
 
 - (void)updateTrackingAreas
@@ -994,58 +1130,6 @@ QT_WARNING_POP
     m_platformWindow->m_enterLeaveTargetWindow = 0;
 }
 
-- (void)rightMouseDown:(NSEvent *)theEvent
-{
-    if (m_window && (m_window->flags() & Qt::WindowTransparentForInput) )
-        return [super rightMouseDown:theEvent];
-    m_buttons |= Qt::RightButton;
-    m_sendUpAsRightButton = true;
-    [self handleMouseEvent:theEvent];
-}
-
-- (void)rightMouseDragged:(NSEvent *)theEvent
-{
-    if (m_window && (m_window->flags() & Qt::WindowTransparentForInput) )
-        return [super rightMouseDragged:theEvent];
-    if (!(m_buttons & Qt::RightButton))
-        qWarning("QNSView rightMouseDragged: Internal mouse button tracking invalid (missing Qt::RightButton)");
-    [self handleMouseEvent:theEvent];
-}
-
-- (void)rightMouseUp:(NSEvent *)theEvent
-{
-    if (m_window && (m_window->flags() & Qt::WindowTransparentForInput) )
-        return [super rightMouseUp:theEvent];
-    m_buttons &= ~Qt::RightButton;
-    m_sendUpAsRightButton = false;
-    [self handleMouseEvent:theEvent];
-}
-
-- (void)otherMouseDown:(NSEvent *)theEvent
-{
-    if (m_window && (m_window->flags() & Qt::WindowTransparentForInput) )
-        return [super otherMouseDown:theEvent];
-    m_buttons |= cocoaButton2QtButton([theEvent buttonNumber]);
-    [self handleMouseEvent:theEvent];
-}
-
-- (void)otherMouseDragged:(NSEvent *)theEvent
-{
-    if (m_window && (m_window->flags() & Qt::WindowTransparentForInput) )
-        return [super otherMouseDragged:theEvent];
-    if (!(m_buttons & ~(Qt::LeftButton | Qt::RightButton)))
-        qWarning("QNSView otherMouseDragged: Internal mouse button tracking invalid (missing Qt::MiddleButton or Qt::ExtraButton*)");
-    [self handleMouseEvent:theEvent];
-}
-
-- (void)otherMouseUp:(NSEvent *)theEvent
-{
-    if (m_window && (m_window->flags() & Qt::WindowTransparentForInput) )
-        return [super otherMouseUp:theEvent];
-    m_buttons &= ~cocoaButton2QtButton([theEvent buttonNumber]);
-    [self handleMouseEvent:theEvent];
-}
-
 struct QCocoaTabletDeviceData
 {
     QTabletEvent::TabletDevice device;
@@ -1413,8 +1497,10 @@ static QTabletEvent::TabletDevice wacomTabletDevice(NSEvent *theEvent)
     } else if (phase == NSEventPhaseNone && momentumPhase == NSEventPhaseNone) {
         ph = Qt::NoScrollPhase;
     }
+    // "isInverted": natural OS X scrolling, inverted from the Qt/other platform/Jens perspective.
+    bool isInverted  = [theEvent isDirectionInvertedFromDevice];
 
-    QWindowSystemInterface::handleWheelEvent(m_window, qt_timestamp, qt_windowPoint, qt_screenPoint, pixelDelta, angleDelta, currentWheelModifiers, ph, source);
+    QWindowSystemInterface::handleWheelEvent(m_window, qt_timestamp, qt_windowPoint, qt_screenPoint, pixelDelta, angleDelta, currentWheelModifiers, ph, source, isInverted);
 }
 #endif //QT_NO_WHEELEVENT
 
@@ -1439,7 +1525,7 @@ static QTabletEvent::TabletDevice wacomTabletDevice(NSEvent *theEvent)
     return qtMods;
 }
 
-- (void)handleKeyEvent:(NSEvent *)nsevent eventType:(int)eventType
+- (bool)handleKeyEvent:(NSEvent *)nsevent eventType:(int)eventType
 {
     ulong timestamp = [nsevent timestamp] * 1000;
     ulong nativeModifiers = [nsevent modifierFlags];
@@ -1509,26 +1595,46 @@ static QTabletEvent::TabletDevice wacomTabletDevice(NSEvent *theEvent)
             m_sendKeyEvent = true;
     }
 
-    if (m_sendKeyEvent && m_composingText.isEmpty())
+    bool accepted = true;
+    if (m_sendKeyEvent && m_composingText.isEmpty()) {
         QWindowSystemInterface::handleExtendedKeyEvent(window, timestamp, QEvent::Type(eventType), keyCode, modifiers,
                                                        nativeScanCode, nativeVirtualKey, nativeModifiers, text, [nsevent isARepeat], 1, false);
-
+        accepted = QWindowSystemInterface::flushWindowSystemEvents();
+    }
     m_sendKeyEvent = false;
     m_resendKeyEvent = false;
+    return accepted;
 }
 
 - (void)keyDown:(NSEvent *)nsevent
 {
     if (m_window && (m_window->flags() & Qt::WindowTransparentForInput) )
         return [super keyDown:nsevent];
-    [self handleKeyEvent:nsevent eventType:int(QEvent::KeyPress)];
+
+    const bool accepted = [self handleKeyEvent:nsevent eventType:int(QEvent::KeyPress)];
+
+    // Track keyDown acceptance state for later acceptance of the keyUp.
+    if (accepted)
+        m_acceptedKeyDowns.insert([nsevent keyCode]);
+
+    // Propagate the keyDown to the next responder if Qt did not accept it.
+    if (!accepted)
+        [super keyDown:nsevent];
 }
 
 - (void)keyUp:(NSEvent *)nsevent
 {
     if (m_window && (m_window->flags() & Qt::WindowTransparentForInput) )
         return [super keyUp:nsevent];
-    [self handleKeyEvent:nsevent eventType:int(QEvent::KeyRelease)];
+
+    const bool keyUpAccepted = [self handleKeyEvent:nsevent eventType:int(QEvent::KeyRelease)];
+
+    // Propagate the keyUp if neither Qt accepted it nor the corresponding KeyDown was
+    // accepted. Qt text controls wil often not use and ignore keyUp events, but we
+    // want to avoid propagating unmatched keyUps.
+    const bool keyDownAccepted = m_acceptedKeyDowns.remove([nsevent keyCode]);
+    if (!keyUpAccepted && !keyDownAccepted)
+        [super keyUp:nsevent];
 }
 
 - (void)cancelOperation:(id)sender
diff --git a/src/plugins/platforms/cocoa/qt_mac_p.h b/src/plugins/platforms/cocoa/qt_mac_p.h
index 18a3d1b3e5d..03eae1b2e7b 100644
--- a/src/plugins/platforms/cocoa/qt_mac_p.h
+++ b/src/plugins/platforms/cocoa/qt_mac_p.h
@@ -64,6 +64,7 @@
 #include "QtCore/qvariant.h"
 #include "QtCore/qmimedata.h"
 #include "QtCore/qpointer.h"
+#include "QtCore/qloggingcategory.h"
 #include "private/qcore_mac_p.h"
 
 
diff --git a/src/plugins/platforms/direct2d/direct2d.pro b/src/plugins/platforms/direct2d/direct2d.pro
index 8f2ccc3aa65..005a4da6db8 100644
--- a/src/plugins/platforms/direct2d/direct2d.pro
+++ b/src/plugins/platforms/direct2d/direct2d.pro
@@ -1,10 +1,5 @@
 TARGET = qdirect2d
 
-PLUGIN_TYPE = platforms
-PLUGIN_CLASS_NAME = QWindowsDirect2DIntegrationPlugin
-!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
-load(qt_plugin)
-
 QT *= core-private
 QT *= gui-private
 QT *= platformsupport-private
@@ -40,3 +35,8 @@ HEADERS += \
     qwindowsdirect2dwindow.h
 
 OTHER_FILES += direct2d.json
+
+PLUGIN_TYPE = platforms
+PLUGIN_CLASS_NAME = QWindowsDirect2DIntegrationPlugin
+!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
+load(qt_plugin)
diff --git a/src/plugins/platforms/directfb/directfb.pro b/src/plugins/platforms/directfb/directfb.pro
index 89d8d42ceae..5c81e0283a1 100644
--- a/src/plugins/platforms/directfb/directfb.pro
+++ b/src/plugins/platforms/directfb/directfb.pro
@@ -1,10 +1,5 @@
 TARGET = qdirectfb
 
-PLUGIN_TYPE = platforms
-PLUGIN_CLASS_NAME = QDirectFbIntegrationPlugin
-!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
-load(qt_plugin)
-
 QT += core-private gui-private platformsupport-private
 
 LIBS += $$QMAKE_LIBS_DIRECTFB
@@ -51,3 +46,8 @@ contains(QT_CONFIG, directfb_egl) {
 CONFIG += qpa/genericunixfontdatabase
 
 OTHER_FILES += directfb.json
+
+PLUGIN_TYPE = platforms
+PLUGIN_CLASS_NAME = QDirectFbIntegrationPlugin
+!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
+load(qt_plugin)
diff --git a/src/plugins/platforms/directfb/qdirectfbbackingstore.cpp b/src/plugins/platforms/directfb/qdirectfbbackingstore.cpp
index ebb8dc1571b..9786f66b7c2 100644
--- a/src/plugins/platforms/directfb/qdirectfbbackingstore.cpp
+++ b/src/plugins/platforms/directfb/qdirectfbbackingstore.cpp
@@ -71,7 +71,7 @@ void QDirectFbBackingStore::flush(QWindow *, const QRegion &region, const QPoint
     m_pmdata->blittable()->unlock();
 
     for (const QRect &rect : region) {
-        DFBRegion dfbReg = { rect.x() + offset.x(),rect.y() + offset.y(),rect.right() + offset.x(),rect.bottom() + offset.y()};
+        DFBRegion dfbReg(rect.x() + offset.x(),rect.y() + offset.y(),rect.right() + offset.x(),rect.bottom() + offset.y());
         m_dfbSurface->Flip(m_dfbSurface.data(), &dfbReg, DFBSurfaceFlipFlags(DSFLIP_BLIT|DSFLIP_ONSYNC));
     }
 }
@@ -90,9 +90,9 @@ void QDirectFbBackingStore::resize(const QSize &size, const QRegion& reg)
 
 static inline void scrollSurface(IDirectFBSurface *surface, const QRect &r, int dx, int dy)
 {
-    const DFBRectangle rect = { r.x(), r.y(), r.width(), r.height() };
+    const DFBRectangle rect(r.x(), r.y(), r.width(), r.height());
     surface->Blit(surface, surface, &rect, r.x() + dx, r.y() + dy);
-    const DFBRegion region = { rect.x + dx, rect.y + dy, r.right() + dx, r.bottom() + dy };
+    const DFBRegion region(rect.x + dx, rect.y + dy, r.right() + dx, r.bottom() + dy);
     surface->Flip(surface, &region, DFBSurfaceFlipFlags(DSFLIP_BLIT));
 }
 
diff --git a/src/plugins/platforms/directfb/qdirectfbblitter.cpp b/src/plugins/platforms/directfb/qdirectfbblitter.cpp
index 939bab9303b..3e21a1925dd 100644
--- a/src/plugins/platforms/directfb/qdirectfbblitter.cpp
+++ b/src/plugins/platforms/directfb/qdirectfbblitter.cpp
@@ -179,8 +179,8 @@ void QDirectFbBlitter::drawPixmapOpacity(const QRectF &rect, const QPixmap &pixm
 {
     QRect sQRect = subrect.toRect();
     QRect dQRect = rect.toRect();
-    DFBRectangle sRect = { sQRect.x(), sQRect.y(), sQRect.width(), sQRect.height() };
-    DFBRectangle dRect = { dQRect.x(), dQRect.y(), dQRect.width(), dQRect.height() };
+    DFBRectangle sRect(sQRect.x(), sQRect.y(), sQRect.width(), sQRect.height());
+    DFBRectangle dRect(dQRect.x(), dQRect.y(), dQRect.width(), dQRect.height());
     DFBResult result;
 
     // skip if dst too small
diff --git a/src/plugins/platforms/directfb/qdirectfbglcontext.cpp b/src/plugins/platforms/directfb/qdirectfbglcontext.cpp
index 1136591c78c..8018433fb6e 100644
--- a/src/plugins/platforms/directfb/qdirectfbglcontext.cpp
+++ b/src/plugins/platforms/directfb/qdirectfbglcontext.cpp
@@ -40,6 +40,7 @@
 #include "qdirectfbglcontext.h"
 
 #include <directfbgl.h>
+#include <dlfcn.h>
 
 #include <QDebug>
 
@@ -80,19 +81,19 @@ void QDirectFbGLContext::doneCurrent()
     m_dfbGlContext->Unlock(m_dfbGlContext);
 }
 
-void *QDirectFbGLContext::getProcAddress(const QString &procName)
+QFunctionPointer QDirectFbGLContext::getProcAddress(const char *procName)
 {
     void *proc;
-    DFBResult result = m_dfbGlContext->GetProcAddress(m_dfbGlContext,qPrintable(procName),&proc);
+    DFBResult result = m_dfbGlContext->GetProcAddress(m_dfbGlContext, procName, &proc);
     if (result == DFB_OK)
-        return proc;
-    return 0;
+        return (QFunctionPointer) proc;
+    return dlsym(RTLD_DEFAULT, procName);
 }
 
 void QDirectFbGLContext::swapBuffers()
 {
 //    m_dfbGlContext->Unlock(m_dfbGlContext); //maybe not in doneCurrent()
-    qDebug() << "Swap buffers";
+    qDebug("Swap buffers");
 }
 
 QPlatformWindowFormat QDirectFbGLContext::platformWindowFormat() const
diff --git a/src/plugins/platforms/eglfs/deviceintegration/eglfs_brcm/eglfs_brcm.pro b/src/plugins/platforms/eglfs/deviceintegration/eglfs_brcm/eglfs_brcm.pro
index 2026b6a6c6b..e2ebf9f7ee5 100644
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_brcm/eglfs_brcm.pro
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_brcm/eglfs_brcm.pro
@@ -1,9 +1,5 @@
 TARGET = qeglfs-brcm-integration
 
-PLUGIN_TYPE = egldeviceintegrations
-PLUGIN_CLASS_NAME = QEglFSBrcmIntegrationPlugin
-load(qt_plugin)
-
 QT += core-private gui-private platformsupport-private eglfs_device_lib-private
 
 INCLUDEPATH += $$PWD/../..
@@ -21,3 +17,7 @@ SOURCES += $$PWD/qeglfsbrcmmain.cpp \
 HEADERS += $$PWD/qeglfsbrcmintegration.h
 
 OTHER_FILES += $$PWD/eglfs_brcm.json
+
+PLUGIN_TYPE = egldeviceintegrations
+PLUGIN_CLASS_NAME = QEglFSBrcmIntegrationPlugin
+load(qt_plugin)
diff --git a/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms/eglfs_kms.pro b/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms/eglfs_kms.pro
index e53793ce546..12ae0a13b1a 100644
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms/eglfs_kms.pro
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms/eglfs_kms.pro
@@ -1,9 +1,5 @@
 TARGET = qeglfs-kms-integration
 
-PLUGIN_TYPE = egldeviceintegrations
-PLUGIN_CLASS_NAME = QEglFSKmsIntegrationPlugin
-load(qt_plugin)
-
 QT += core-private gui-private platformsupport-private eglfs_device_lib-private
 
 INCLUDEPATH += $$PWD/../..
@@ -29,3 +25,7 @@ HEADERS += $$PWD/qeglfskmsintegration.h \
            $$PWD/qeglfskmscursor.h
 
 OTHER_FILES += $$PWD/eglfs_kms.json
+
+PLUGIN_TYPE = egldeviceintegrations
+PLUGIN_CLASS_NAME = QEglFSKmsIntegrationPlugin
+load(qt_plugin)
diff --git a/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/eglfs_kms_egldevice.pro b/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/eglfs_kms_egldevice.pro
index 393ddd14a5d..1932f861b9a 100644
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/eglfs_kms_egldevice.pro
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_kms_egldevice/eglfs_kms_egldevice.pro
@@ -1,9 +1,5 @@
 TARGET = qeglfs-kms-egldevice-integration
 
-PLUGIN_TYPE = egldeviceintegrations
-PLUGIN_CLASS_NAME = QEglFSKmsEglDeviceIntegrationPlugin
-load(qt_plugin)
-
 QT += core-private gui-private platformsupport-private eglfs_device_lib-private
 
 INCLUDEPATH += $$PWD/../..
@@ -21,3 +17,7 @@ HEADERS += $$PWD/qeglfskmsegldeviceintegration.h
 OTHER_FILES += $$PWD/eglfs_kms_egldevice.json
 
 LIBS += -ldrm
+
+PLUGIN_TYPE = egldeviceintegrations
+PLUGIN_CLASS_NAME = QEglFSKmsEglDeviceIntegrationPlugin
+load(qt_plugin)
diff --git a/src/plugins/platforms/eglfs/deviceintegration/eglfs_mali/eglfs_mali.pro b/src/plugins/platforms/eglfs/deviceintegration/eglfs_mali/eglfs_mali.pro
index 33f219db96e..7fc4568ae3f 100644
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_mali/eglfs_mali.pro
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_mali/eglfs_mali.pro
@@ -1,9 +1,5 @@
 TARGET = qeglfs-mali-integration
 
-PLUGIN_TYPE = egldeviceintegrations
-PLUGIN_CLASS_NAME = QEglFSMaliIntegrationPlugin
-load(qt_plugin)
-
 QT += core-private gui-private platformsupport-private eglfs_device_lib-private
 
 # Avoid X11 header collision
@@ -19,3 +15,7 @@ SOURCES += $$PWD/qeglfsmalimain.cpp \
 HEADERS += $$PWD/qeglfsmaliintegration.h
 
 OTHER_FILES += $$PWD/eglfs_mali.json
+
+PLUGIN_TYPE = egldeviceintegrations
+PLUGIN_CLASS_NAME = QEglFSMaliIntegrationPlugin
+load(qt_plugin)
diff --git a/src/plugins/platforms/eglfs/deviceintegration/eglfs_viv/eglfs_viv.pro b/src/plugins/platforms/eglfs/deviceintegration/eglfs_viv/eglfs_viv.pro
index fc0533127cb..6fac2f529ab 100644
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_viv/eglfs_viv.pro
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_viv/eglfs_viv.pro
@@ -1,9 +1,5 @@
 TARGET = qeglfs-viv-integration
 
-PLUGIN_TYPE = egldeviceintegrations
-PLUGIN_CLASS_NAME = QEglFSVivIntegrationPlugin
-load(qt_plugin)
-
 QT += core-private gui-private platformsupport-private eglfs_device_lib-private
 
 INCLUDEPATH += $$PWD/../..
@@ -18,3 +14,7 @@ SOURCES += $$PWD/qeglfsvivmain.cpp \
 HEADERS += $$PWD/qeglfsvivintegration.h
 
 OTHER_FILES += $$PWD/eglfs_viv.json
+
+PLUGIN_TYPE = egldeviceintegrations
+PLUGIN_CLASS_NAME = QEglFSVivIntegrationPlugin
+load(qt_plugin)
diff --git a/src/plugins/platforms/eglfs/deviceintegration/eglfs_viv_wl/eglfs_viv_wl.pro b/src/plugins/platforms/eglfs/deviceintegration/eglfs_viv_wl/eglfs_viv_wl.pro
index 26b6a2e9eab..44f75c40e04 100644
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_viv_wl/eglfs_viv_wl.pro
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_viv_wl/eglfs_viv_wl.pro
@@ -1,9 +1,5 @@
 TARGET = qeglfs-viv-wl-integration
 
-PLUGIN_TYPE = egldeviceintegrations
-PLUGIN_CLASS_NAME = QEglFSVivWaylandIntegrationPlugin
-load(qt_plugin)
-
 QT += core-private gui-private platformsupport-private eglfs_device_lib-private
 
 INCLUDEPATH += $$PWD/../..
@@ -21,3 +17,7 @@ OTHER_FILES += $$PWD/eglfs_viv_wl.json
 
 CONFIG += link_pkgconfig
 PKGCONFIG_PRIVATE += wayland-server
+
+PLUGIN_TYPE = egldeviceintegrations
+PLUGIN_CLASS_NAME = QEglFSVivWaylandIntegrationPlugin
+load(qt_plugin)
diff --git a/src/plugins/platforms/eglfs/deviceintegration/eglfs_x11/eglfs_x11.pro b/src/plugins/platforms/eglfs/deviceintegration/eglfs_x11/eglfs_x11.pro
index 86fefac8aa2..83f0c74910b 100644
--- a/src/plugins/platforms/eglfs/deviceintegration/eglfs_x11/eglfs_x11.pro
+++ b/src/plugins/platforms/eglfs/deviceintegration/eglfs_x11/eglfs_x11.pro
@@ -1,9 +1,5 @@
 TARGET = qeglfs-x11-integration
 
-PLUGIN_TYPE = egldeviceintegrations
-PLUGIN_CLASS_NAME = QEglFSX11IntegrationPlugin
-load(qt_plugin)
-
 QT += core-private gui-private platformsupport-private eglfs_device_lib-private
 
 # Avoid X11 header collision
@@ -21,3 +17,7 @@ SOURCES += $$PWD/qeglfsx11main.cpp \
 HEADERS += $$PWD/qeglfsx11integration.h
 
 OTHER_FILES += $$PWD/eglfs_x11.json
+
+PLUGIN_TYPE = egldeviceintegrations
+PLUGIN_CLASS_NAME = QEglFSX11IntegrationPlugin
+load(qt_plugin)
diff --git a/src/plugins/platforms/eglfs/eglfs-plugin.pro b/src/plugins/platforms/eglfs/eglfs-plugin.pro
index 0f493fdc01d..a628cdccd93 100644
--- a/src/plugins/platforms/eglfs/eglfs-plugin.pro
+++ b/src/plugins/platforms/eglfs/eglfs-plugin.pro
@@ -1,12 +1,12 @@
 TARGET = qeglfs
 
-PLUGIN_TYPE = platforms
-PLUGIN_CLASS_NAME = QEglFSIntegrationPlugin
-!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
-load(qt_plugin)
-
 QT += platformsupport-private eglfs_device_lib-private
 
 SOURCES += $$PWD/qeglfsmain.cpp
 
 OTHER_FILES += $$PWD/eglfs.json
+
+PLUGIN_TYPE = platforms
+PLUGIN_CLASS_NAME = QEglFSIntegrationPlugin
+!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
+load(qt_plugin)
diff --git a/src/plugins/platforms/eglfs/eglfs_device_lib.pro b/src/plugins/platforms/eglfs/eglfs_device_lib.pro
index 4fe2ce4897f..f784020fb62 100644
--- a/src/plugins/platforms/eglfs/eglfs_device_lib.pro
+++ b/src/plugins/platforms/eglfs/eglfs_device_lib.pro
@@ -6,8 +6,6 @@
 TARGET = QtEglDeviceIntegration
 CONFIG += no_module_headers internal_module
 
-load(qt_module)
-
 QT += core-private gui-private platformsupport-private
 LIBS += $$QMAKE_LIBS_DYNLOAD
 
@@ -52,3 +50,5 @@ INCLUDEPATH += $$PWD
 CONFIG += egl qpa/genericunixfontdatabase
 
 !contains(DEFINES, QT_NO_CURSOR): RESOURCES += $$PWD/cursor.qrc
+
+load(qt_module)
diff --git a/src/plugins/platforms/haiku/haiku.pro b/src/plugins/platforms/haiku/haiku.pro
index 87f31997a31..ea5bb632db3 100644
--- a/src/plugins/platforms/haiku/haiku.pro
+++ b/src/plugins/platforms/haiku/haiku.pro
@@ -1,7 +1,4 @@
 TARGET = qhaiku
-PLUGIN_TYPE = platforms
-PLUGIN_CLASS_NAME = QHaikuIntegrationPlugin
-load(qt_plugin)
 
 QT += platformsupport-private core-private gui-private
 
@@ -40,3 +37,7 @@ LIBS += -lbe
 OTHER_FILES += haiku.json
 
 include (../../../platformsupport/fontdatabases/fontdatabases.pri)
+
+PLUGIN_TYPE = platforms
+PLUGIN_CLASS_NAME = QHaikuIntegrationPlugin
+load(qt_plugin)
diff --git a/src/plugins/platforms/ios/ios.pro b/src/plugins/platforms/ios/ios.pro
index b1075d3c0f6..d82b47fb74e 100644
--- a/src/plugins/platforms/ios/ios.pro
+++ b/src/plugins/platforms/ios/ios.pro
@@ -1,10 +1,5 @@
 TARGET = qios
 
-PLUGIN_TYPE = platforms
-PLUGIN_CLASS_NAME = QIOSIntegrationPlugin
-!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
-load(qt_plugin)
-
 QT += core-private gui-private platformsupport-private
 LIBS += -framework Foundation -framework UIKit -framework QuartzCore -framework AssetsLibrary -framework AudioToolbox
 
@@ -61,3 +56,8 @@ HEADERS = \
 OTHER_FILES = \
     quiview_textinput.mm \
     quiview_accessibility.mm
+
+PLUGIN_TYPE = platforms
+PLUGIN_CLASS_NAME = QIOSIntegrationPlugin
+!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
+load(qt_plugin)
diff --git a/src/plugins/platforms/ios/qiosbackingstore.mm b/src/plugins/platforms/ios/qiosbackingstore.mm
index 4a39c4d7abc..fb0c9805f9c 100644
--- a/src/plugins/platforms/ios/qiosbackingstore.mm
+++ b/src/plugins/platforms/ios/qiosbackingstore.mm
@@ -149,12 +149,12 @@ void QIOSBackingStore::flush(QWindow *window, const QRegion &region, const QPoin
     }
 
     if (window->surfaceType() == QSurface::RasterGLSurface) {
-        QPainter painter(m_glDevice);
-        painter.drawImage(QPoint(), m_image);
+        static QPlatformTextureList emptyTextureList;
+        composeAndFlush(window, region, offset, &emptyTextureList, m_context, false);
+    } else {
+        m_context->makeCurrent(window);
+        m_context->swapBuffers(window);
     }
-
-    m_context->makeCurrent(window);
-    m_context->swapBuffers(window);
 }
 
 void QIOSBackingStore::resize(const QSize &size, const QRegion &staticContents)
@@ -169,7 +169,7 @@ void QIOSBackingStore::resize(const QSize &size, const QRegion &staticContents)
         // size in beginPaint().
 
         if (size != window()->size() && !window()->inherits("QWidgetWindow"))
-            qWarning() << "QIOSBackingStore needs to have the same size as its window";
+            qWarning("QIOSBackingStore needs to have the same size as its window");
 
         return;
     }
diff --git a/src/plugins/platforms/ios/qioscontext.h b/src/plugins/platforms/ios/qioscontext.h
index 53ef1d7b54b..c8a4fae20ca 100644
--- a/src/plugins/platforms/ios/qioscontext.h
+++ b/src/plugins/platforms/ios/qioscontext.h
@@ -64,7 +64,7 @@ public:
     void doneCurrent() Q_DECL_OVERRIDE;
 
     GLuint defaultFramebufferObject(QPlatformSurface *) const Q_DECL_OVERRIDE;
-    QFunctionPointer getProcAddress(const QByteArray &procName) Q_DECL_OVERRIDE;
+    QFunctionPointer getProcAddress(const char *procName) Q_DECL_OVERRIDE;
 
     bool isSharing() const Q_DECL_OVERRIDE;
     bool isValid() const Q_DECL_OVERRIDE;
diff --git a/src/plugins/platforms/ios/qioscontext.mm b/src/plugins/platforms/ios/qioscontext.mm
index b7ca88b9eed..546b003d14e 100644
--- a/src/plugins/platforms/ios/qioscontext.mm
+++ b/src/plugins/platforms/ios/qioscontext.mm
@@ -266,9 +266,9 @@ void QIOSContext::windowDestroyed(QObject *object)
     }
 }
 
-QFunctionPointer QIOSContext::getProcAddress(const QByteArray& functionName)
+QFunctionPointer QIOSContext::getProcAddress(const char *functionName)
 {
-    return QFunctionPointer(dlsym(RTLD_DEFAULT, functionName.constData()));
+    return QFunctionPointer(dlsym(RTLD_DEFAULT, functionName));
 }
 
 bool QIOSContext::isValid() const
diff --git a/src/plugins/platforms/ios/qiosglobal.h b/src/plugins/platforms/ios/qiosglobal.h
index 06ebf4809c1..0fe81ceb91e 100644
--- a/src/plugins/platforms/ios/qiosglobal.h
+++ b/src/plugins/platforms/ios/qiosglobal.h
@@ -50,11 +50,11 @@ QT_BEGIN_NAMESPACE
 Q_DECLARE_LOGGING_CATEGORY(lcQpaInputMethods);
 
 #if !defined(QT_NO_DEBUG)
-#define qImDebug(...) \
+#define qImDebug \
     for (bool qt_category_enabled = lcQpaInputMethods().isDebugEnabled(); qt_category_enabled; qt_category_enabled = false) \
-        QMessageLogger(QT_MESSAGELOG_FILE, QT_MESSAGELOG_LINE, QT_MESSAGELOG_FUNC, lcQpaInputMethods().categoryName()).debug(__VA_ARGS__)
+        QMessageLogger(QT_MESSAGELOG_FILE, QT_MESSAGELOG_LINE, QT_MESSAGELOG_FUNC, lcQpaInputMethods().categoryName()).debug
 #else
-#define qImDebug() QT_NO_QDEBUG_MACRO()
+#define qImDebug QT_NO_QDEBUG_MACRO
 #endif
 
 class QPlatformScreen;
diff --git a/src/plugins/platforms/ios/qiosglobal.mm b/src/plugins/platforms/ios/qiosglobal.mm
index 4dd66388ad5..c2f3d6b9e17 100644
--- a/src/plugins/platforms/ios/qiosglobal.mm
+++ b/src/plugins/platforms/ios/qiosglobal.mm
@@ -93,7 +93,7 @@ Qt::ScreenOrientation toQtScreenOrientation(UIDeviceOrientation uiDeviceOrientat
         break;
     case UIDeviceOrientationFaceUp:
     case UIDeviceOrientationFaceDown:
-        qWarning() << "Falling back to Qt::PortraitOrientation for UIDeviceOrientationFaceUp/UIDeviceOrientationFaceDown";
+        qWarning("Falling back to Qt::PortraitOrientation for UIDeviceOrientationFaceUp/UIDeviceOrientationFaceDown");
         qtOrientation = Qt::PortraitOrientation;
         break;
     default:
diff --git a/src/plugins/platforms/ios/qiosinputcontext.mm b/src/plugins/platforms/ios/qiosinputcontext.mm
index f2292ad0ab6..d553d16698b 100644
--- a/src/plugins/platforms/ios/qiosinputcontext.mm
+++ b/src/plugins/platforms/ios/qiosinputcontext.mm
@@ -227,7 +227,7 @@ static QUIView *focusView()
     Q_UNUSED(sender);
 
     if (self.state == UIGestureRecognizerStateBegan) {
-        qImDebug() << "hide keyboard gesture was triggered";
+        qImDebug("hide keyboard gesture was triggered");
         UIResponder *firstResponder = [UIResponder currentFirstResponder];
         Q_ASSERT([firstResponder isKindOfClass:[QIOSTextInputResponder class]]);
         [firstResponder resignFirstResponder];
@@ -239,12 +239,12 @@ static QUIView *focusView()
     [super reset];
 
     if (!m_context->isInputPanelVisible()) {
-        qImDebug() << "keyboard was hidden, disabling hide-keyboard gesture";
+        qImDebug("keyboard was hidden, disabling hide-keyboard gesture");
         self.enabled = NO;
     } else {
-        qImDebug() << "gesture completed without triggering";
+        qImDebug("gesture completed without triggering");
         if (self.hasDeferredScrollToCursor) {
-            qImDebug() << "applying deferred scroll to cursor";
+            qImDebug("applying deferred scroll to cursor");
             m_context->scrollToCursor();
         }
     }
@@ -313,22 +313,22 @@ QIOSInputContext::~QIOSInputContext()
 void QIOSInputContext::showInputPanel()
 {
     // No-op, keyboard controlled fully by platform based on focus
-    qImDebug() << "can't show virtual keyboard without a focus object, ignoring";
+    qImDebug("can't show virtual keyboard without a focus object, ignoring");
 }
 
 void QIOSInputContext::hideInputPanel()
 {
     if (![m_textResponder isFirstResponder]) {
-        qImDebug() << "QIOSTextInputResponder is not first responder, ignoring";
+        qImDebug("QIOSTextInputResponder is not first responder, ignoring");
         return;
     }
 
     if (qGuiApp->focusObject() != m_imeState.focusObject) {
-        qImDebug() << "current focus object does not match IM state, likely hiding from focusOut event, so ignoring";
+        qImDebug("current focus object does not match IM state, likely hiding from focusOut event, so ignoring");
         return;
     }
 
-    qImDebug() << "hiding VKB as requested by QInputMethod::hide()";
+    qImDebug("hiding VKB as requested by QInputMethod::hide()");
     [m_textResponder resignFirstResponder];
 }
 
@@ -380,7 +380,7 @@ void QIOSInputContext::updateKeyboardState(NSNotification *notification)
         qImDebug() << qPrintable(QString::fromNSString(notification.name)) << "from" << fromCGRect(frameBegin) << "to" << fromCGRect(frameEnd)
                    << "(curve =" << m_keyboardState.animationCurve << "duration =" << m_keyboardState.animationDuration << "s)";
     } else {
-        qImDebug() << "No notification to update keyboard state based on, just updating keyboard rect";
+        qImDebug("No notification to update keyboard state based on, just updating keyboard rect");
     }
 
     if (!focusView() || CGRectIsEmpty(currentKeyboardRect))
@@ -434,7 +434,7 @@ void QIOSInputContext::scrollToCursor()
     if (m_keyboardHideGesture.state == UIGestureRecognizerStatePossible && m_keyboardHideGesture.numberOfTouches == 1) {
         // Don't scroll to the cursor if the user is touching the screen and possibly
         // trying to trigger the hide-keyboard gesture.
-        qImDebug() << "deferring scrolling to cursor as we're still waiting for a possible gesture";
+        qImDebug("deferring scrolling to cursor as we're still waiting for a possible gesture");
         m_keyboardHideGesture.hasDeferredScrollToCursor = YES;
         return;
     }
@@ -451,7 +451,7 @@ void QIOSInputContext::scrollToCursor()
 
     // We only support auto-scroll for docked keyboards for now, so make sure that's the case
     if (CGRectGetMaxY(m_keyboardState.keyboardEndRect) != CGRectGetMaxY([UIScreen mainScreen].bounds)) {
-        qImDebug() << "Keyboard not docked, ignoring request to scroll to reveal cursor";
+        qImDebug("Keyboard not docked, ignoring request to scroll to reveal cursor");
         return;
     }
 
@@ -550,7 +550,7 @@ void QIOSInputContext::setFocusObject(QObject *focusObject)
         clearCurrentFocusObject();
         return;
     } else if (focusObject == m_imeState.focusObject) {
-        qImDebug() << "same focus object as last update, skipping reset";
+        qImDebug("same focus object as last update, skipping reset");
         return;
     }
 
@@ -594,23 +594,23 @@ void QIOSInputContext::update(Qt::InputMethodQueries updatedProperties)
 
     if (inputMethodAccepted()) {
         if (!m_textResponder || [m_textResponder needsKeyboardReconfigure:changedProperties]) {
-            qImDebug() << "creating new text responder";
+            qImDebug("creating new text responder");
             [m_textResponder autorelease];
             m_textResponder = [[QIOSTextInputResponder alloc] initWithInputContext:this];
         } else {
-            qImDebug() << "no need to reconfigure keyboard, just notifying input delegate";
+            qImDebug("no need to reconfigure keyboard, just notifying input delegate");
             [m_textResponder notifyInputDelegate:changedProperties];
         }
 
         if (![m_textResponder isFirstResponder]) {
-            qImDebug() << "IM enabled, making text responder first responder";
+            qImDebug("IM enabled, making text responder first responder");
             [m_textResponder becomeFirstResponder];
         }
 
         if (changedProperties & Qt::ImCursorRectangle)
             scrollToCursor();
     } else if ([m_textResponder isFirstResponder]) {
-        qImDebug() << "IM not enabled, resigning text responder as first responder";
+        qImDebug("IM not enabled, resigning text responder as first responder");
         [m_textResponder resignFirstResponder];
     }
 }
@@ -640,7 +640,7 @@ bool QIOSInputContext::inputMethodAccepted() const
 */
 void QIOSInputContext::reset()
 {
-    qImDebug() << "updating Qt::ImQueryAll and unmarking text";
+    qImDebug("updating Qt::ImQueryAll and unmarking text");
 
     update(Qt::ImQueryAll);
 
@@ -658,7 +658,7 @@ void QIOSInputContext::reset()
 */
 void QIOSInputContext::commit()
 {
-    qImDebug() << "unmarking text";
+    qImDebug("unmarking text");
 
     [m_textResponder unmarkText];
     [m_textResponder notifyInputDelegate:Qt::ImSurroundingText];
diff --git a/src/plugins/platforms/ios/qiostextresponder.mm b/src/plugins/platforms/ios/qiostextresponder.mm
index a894963bbe3..6a66bf213e7 100644
--- a/src/plugins/platforms/ios/qiostextresponder.mm
+++ b/src/plugins/platforms/ios/qiostextresponder.mm
@@ -261,7 +261,7 @@
         // as well, as the IM state that we were based on may have been invalidated when
         // IM was switched off.
 
-        qImDebug() << "IM was turned on, we need to check hints and platform data as well";
+        qImDebug("IM was turned on, we need to check hints and platform data as well");
         updatedProperties |= (Qt::ImHints | Qt::ImPlatformData);
     }
 
@@ -311,7 +311,7 @@
     // Don't allow activation events of the window that we're doing text on behalf on
     // to steal responder.
     if (FirstResponderCandidate::currentCandidate() == [self nextResponder]) {
-        qImDebug() << "not allowing parent window to steal responder";
+        qImDebug("not allowing parent window to steal responder");
         return NO;
     }
 
@@ -334,7 +334,7 @@
         if ([self currentImeState:Qt::ImEnabled].toBool()) {
             // The current focus object expects text input, but there
             // is no keyboard to get input from. So we clear focus.
-            qImDebug() << "no keyboard available, clearing focus object";
+            qImDebug("no keyboard available, clearing focus object");
             m_inputContext->clearCurrentFocusObject();
         }
     } else {
@@ -342,7 +342,7 @@
         // another QIOSTextResponder was made first-responder, another UIView was
         // made first-responder, or the first-responder was cleared globally. In
         // either of these cases we don't have to do anything.
-        qImDebug() << "lost first responder, but not clearing focus object";
+        qImDebug("lost first responder, but not clearing focus object");
     }
 
     return YES;
diff --git a/src/plugins/platforms/linuxfb/linuxfb.pro b/src/plugins/platforms/linuxfb/linuxfb.pro
index 389d45c29c4..b5de1923467 100644
--- a/src/plugins/platforms/linuxfb/linuxfb.pro
+++ b/src/plugins/platforms/linuxfb/linuxfb.pro
@@ -1,10 +1,5 @@
 TARGET = qlinuxfb
 
-PLUGIN_TYPE = platforms
-PLUGIN_CLASS_NAME = QLinuxFbIntegrationPlugin
-!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
-load(qt_plugin)
-
 QT += core-private gui-private platformsupport-private
 
 SOURCES = main.cpp qlinuxfbintegration.cpp qlinuxfbscreen.cpp
@@ -13,3 +8,8 @@ HEADERS = qlinuxfbintegration.h qlinuxfbscreen.h
 CONFIG += qpa/genericunixfontdatabase
 
 OTHER_FILES += linuxfb.json
+
+PLUGIN_TYPE = platforms
+PLUGIN_CLASS_NAME = QLinuxFbIntegrationPlugin
+!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
+load(qt_plugin)
diff --git a/src/plugins/platforms/minimal/minimal.pro b/src/plugins/platforms/minimal/minimal.pro
index 3ed4d2cdde1..d6914026ae5 100644
--- a/src/plugins/platforms/minimal/minimal.pro
+++ b/src/plugins/platforms/minimal/minimal.pro
@@ -1,10 +1,5 @@
 TARGET = qminimal
 
-PLUGIN_TYPE = platforms
-PLUGIN_CLASS_NAME = QMinimalIntegrationPlugin
-!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
-load(qt_plugin)
-
 QT += core-private gui-private platformsupport-private
 
 SOURCES =   main.cpp \
@@ -14,3 +9,8 @@ HEADERS =   qminimalintegration.h \
             qminimalbackingstore.h
 
 OTHER_FILES += minimal.json
+
+PLUGIN_TYPE = platforms
+PLUGIN_CLASS_NAME = QMinimalIntegrationPlugin
+!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
+load(qt_plugin)
diff --git a/src/plugins/platforms/minimal/qminimalbackingstore.cpp b/src/plugins/platforms/minimal/qminimalbackingstore.cpp
index 19a581625a3..402ee7e2ddb 100644
--- a/src/plugins/platforms/minimal/qminimalbackingstore.cpp
+++ b/src/plugins/platforms/minimal/qminimalbackingstore.cpp
@@ -62,7 +62,7 @@ QMinimalBackingStore::~QMinimalBackingStore()
 QPaintDevice *QMinimalBackingStore::paintDevice()
 {
     if (mDebug)
-        qDebug() << "QMinimalBackingStore::paintDevice";
+        qDebug("QMinimalBackingStore::paintDevice");
 
     return &mImage;
 }
diff --git a/src/plugins/platforms/minimalegl/minimalegl.pro b/src/plugins/platforms/minimalegl/minimalegl.pro
index e78dcb8bc50..ac672495914 100644
--- a/src/plugins/platforms/minimalegl/minimalegl.pro
+++ b/src/plugins/platforms/minimalegl/minimalegl.pro
@@ -1,10 +1,5 @@
 TARGET = qminimalegl
 
-PLUGIN_TYPE = platforms
-PLUGIN_CLASS_NAME = QMinimalEglIntegrationPlugin
-!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
-load(qt_plugin)
-
 QT += core-private gui-private platformsupport-private
 
 #DEFINES += QEGL_EXTRA_DEBUG
@@ -29,3 +24,8 @@ CONFIG += egl qpa/genericunixfontdatabase
 
 OTHER_FILES += \
     minimalegl.json
+
+PLUGIN_TYPE = platforms
+PLUGIN_CLASS_NAME = QMinimalEglIntegrationPlugin
+!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
+load(qt_plugin)
diff --git a/src/plugins/platforms/mirclient/mirclient.pro b/src/plugins/platforms/mirclient/mirclient.pro
index 0851e8d7192..d5d35f1632e 100644
--- a/src/plugins/platforms/mirclient/mirclient.pro
+++ b/src/plugins/platforms/mirclient/mirclient.pro
@@ -1,10 +1,4 @@
-TARGET = mirclient
-TEMPLATE = lib
-
-PLUGIN_TYPE = platforms
-PLUGIN_CLASS_NAME = MirServerIntegrationPlugin
-!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
-load(qt_plugin)
+TARGET = qmirclient
 
 QT += core-private gui-private platformsupport-private dbus
 
@@ -47,3 +41,8 @@ HEADERS = \
     qmirclientscreen.h \
     qmirclienttheme.h \
     qmirclientwindow.h
+
+PLUGIN_TYPE = platforms
+PLUGIN_CLASS_NAME = MirServerIntegrationPlugin
+!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
+load(qt_plugin)
diff --git a/src/plugins/platforms/mirclient/qmirclientglcontext.cpp b/src/plugins/platforms/mirclient/qmirclientglcontext.cpp
index e1e7727486c..b1ca0b1f7ca 100644
--- a/src/plugins/platforms/mirclient/qmirclientglcontext.cpp
+++ b/src/plugins/platforms/mirclient/qmirclientglcontext.cpp
@@ -40,6 +40,7 @@
 #include "qmirclientlogging.h"
 #include <QtPlatformSupport/private/qeglconvenience_p.h>
 #include <QtGui/private/qopenglcontext_p.h>
+#include <dlfcn.h>
 
 #if !defined(QT_NO_DEBUG)
 static void printOpenGLESConfig() {
@@ -143,12 +144,15 @@ void QMirClientOpenGLContext::swapBuffers(QPlatformSurface* surface)
     ubuntuWindow->onSwapBuffersDone();
 }
 
-void (*QMirClientOpenGLContext::getProcAddress(const QByteArray& procName)) ()
+QFunctionPointer QMirClientOpenGLContext::getProcAddress(const char *procName)
 {
 #if defined(QT_NO_DEBUG)
     eglBindAPI(api_in_use());
 #else
     ASSERT(eglBindAPI(api_in_use()) == EGL_TRUE);
 #endif
-    return eglGetProcAddress(procName.constData());
+    QFunctionPointer proc = (QFunctionPointer) eglGetProcAddress(procName);
+    if (!proc)
+        proc = (QFunctionPointer) dlsym(RTLD_DEFAULT, procName);
+    return proc;
 }
diff --git a/src/plugins/platforms/mirclient/qmirclientglcontext.h b/src/plugins/platforms/mirclient/qmirclientglcontext.h
index 29c196ce5cc..9278cc7beb1 100644
--- a/src/plugins/platforms/mirclient/qmirclientglcontext.h
+++ b/src/plugins/platforms/mirclient/qmirclientglcontext.h
@@ -53,7 +53,7 @@ public:
     bool makeCurrent(QPlatformSurface* surface) override;
     void doneCurrent() override;
     bool isValid() const override { return mEglContext != EGL_NO_CONTEXT; }
-    void (*getProcAddress(const QByteArray& procName)) () override;
+    QFunctionPointer getProcAddress(const char *procName) override;
 
     EGLContext eglContext() const { return mEglContext; }
 
diff --git a/src/plugins/platforms/mirclient/qmirclientinput.cpp b/src/plugins/platforms/mirclient/qmirclientinput.cpp
index addeda634ca..3af714465b6 100644
--- a/src/plugins/platforms/mirclient/qmirclientinput.cpp
+++ b/src/plugins/platforms/mirclient/qmirclientinput.cpp
@@ -214,7 +214,7 @@ void QMirClientInput::customEvent(QEvent* event)
     const MirEvent *nativeEvent = ubuntuEvent->nativeEvent;
 
     if ((ubuntuEvent->window == nullptr) || (ubuntuEvent->window->window() == nullptr)) {
-        qWarning() << "Attempted to deliver an event to a non-existent window, ignoring.";
+        qWarning("Attempted to deliver an event to a non-existent window, ignoring.");
         return;
     }
 
diff --git a/src/plugins/platforms/offscreen/offscreen.pro b/src/plugins/platforms/offscreen/offscreen.pro
index 94eeac6accb..999550a7e16 100644
--- a/src/plugins/platforms/offscreen/offscreen.pro
+++ b/src/plugins/platforms/offscreen/offscreen.pro
@@ -1,10 +1,5 @@
 TARGET = qoffscreen
 
-PLUGIN_TYPE = platforms
-PLUGIN_CLASS_NAME = QOffscreenIntegrationPlugin
-!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
-load(qt_plugin)
-
 QT += core-private gui-private platformsupport-private
 
 SOURCES =   main.cpp \
@@ -25,3 +20,8 @@ contains(QT_CONFIG, xlib):contains(QT_CONFIG, opengl):!contains(QT_CONFIG, openg
 } else {
     SOURCES += qoffscreenintegration_dummy.cpp
 }
+
+PLUGIN_TYPE = platforms
+PLUGIN_CLASS_NAME = QOffscreenIntegrationPlugin
+!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
+load(qt_plugin)
diff --git a/src/plugins/platforms/offscreen/qoffscreenintegration_x11.cpp b/src/plugins/platforms/offscreen/qoffscreenintegration_x11.cpp
index bec7fc9c967..2187eceed46 100644
--- a/src/plugins/platforms/offscreen/qoffscreenintegration_x11.cpp
+++ b/src/plugins/platforms/offscreen/qoffscreenintegration_x11.cpp
@@ -227,9 +227,9 @@ void QOffscreenX11GLXContext::swapBuffers(QPlatformSurface *)
 {
 }
 
-void (*QOffscreenX11GLXContext::getProcAddress(const QByteArray &procName)) ()
+QFunctionPointer QOffscreenX11GLXContext::getProcAddress(const char *procName)
 {
-    return (void (*)())glXGetProcAddressARB(reinterpret_cast<const GLubyte *>(procName.constData()));
+    return (QFunctionPointer)glXGetProcAddressARB(reinterpret_cast<const GLubyte *>(procName));
 }
 
 QSurfaceFormat QOffscreenX11GLXContext::format() const
diff --git a/src/plugins/platforms/offscreen/qoffscreenintegration_x11.h b/src/plugins/platforms/offscreen/qoffscreenintegration_x11.h
index a19ded7c111..aaca74d2fba 100644
--- a/src/plugins/platforms/offscreen/qoffscreenintegration_x11.h
+++ b/src/plugins/platforms/offscreen/qoffscreenintegration_x11.h
@@ -91,7 +91,7 @@ public:
     bool makeCurrent(QPlatformSurface *surface) Q_DECL_OVERRIDE;
     void doneCurrent() Q_DECL_OVERRIDE;
     void swapBuffers(QPlatformSurface *surface) Q_DECL_OVERRIDE;
-    QFunctionPointer getProcAddress(const QByteArray &procName) Q_DECL_OVERRIDE;
+    QFunctionPointer getProcAddress(const char *procName) Q_DECL_OVERRIDE;
 
     QSurfaceFormat format() const Q_DECL_OVERRIDE;
     bool isSharing() const Q_DECL_OVERRIDE;
diff --git a/src/plugins/platforms/openwfd/openwf.pro b/src/plugins/platforms/openwfd/openwf.pro
index 38bac057bd4..152e4f57d7e 100644
--- a/src/plugins/platforms/openwfd/openwf.pro
+++ b/src/plugins/platforms/openwfd/openwf.pro
@@ -1,10 +1,5 @@
 TARGET = qopenwf
 
-PLUGIN_TYPE = platforms
-PLUGIN_CLASS_NAME = QOpenWFDIntegrationPlugin
-!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
-load(qt_plugin)
-
 QT += core-private gui-private platformsupport-private
 
 CONFIG += qpa/genericunixfontdatabase
@@ -38,3 +33,7 @@ SOURCES += \
 
 LIBS += -lWFD -lgbm -lGLESv2 -lEGL
 
+PLUGIN_TYPE = platforms
+PLUGIN_CLASS_NAME = QOpenWFDIntegrationPlugin
+!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
+load(qt_plugin)
diff --git a/src/plugins/platforms/openwfd/qopenwfddevice.cpp b/src/plugins/platforms/openwfd/qopenwfddevice.cpp
index 1a4ba59817d..7a9d22e74d0 100644
--- a/src/plugins/platforms/openwfd/qopenwfddevice.cpp
+++ b/src/plugins/platforms/openwfd/qopenwfddevice.cpp
@@ -55,11 +55,11 @@ QOpenWFDDevice::QOpenWFDDevice(QOpenWFDIntegration *integration, WFDint device_e
 {
     mDevice = wfdCreateDevice(WFD_DEFAULT_DEVICE_ID,WFD_NONE);
     if (mDevice == WFD_INVALID_HANDLE)
-        qDebug() << "failed to create device";
+        qDebug("failed to create device");
 
     mEvent = wfdCreateEvent(mDevice,0);
     if (mEvent == WFD_INVALID_HANDLE)
-        qDebug() << "failed to create event handle";
+        qDebug("failed to create event handle");
 
     //initialize pipelines for device.
     wfdEnumeratePipelines(mDevice,WFD_NONE,0,WFD_NONE);
@@ -181,22 +181,22 @@ void QOpenWFDDevice::readEvents(WFDtime wait)
     case WFD_EVENT_NONE:
         return;
     case WFD_EVENT_DESTROYED:
-        qDebug() << "Event or Device destoryed!";
+        qDebug("Event or Device destoryed!");
         return;
     case WFD_EVENT_PORT_ATTACH_DETACH:
         handlePortAttachDetach();
         break;
     case WFD_EVENT_PORT_PROTECTION_FAILURE:
-        qDebug() << "Port protection event handling not implemented";
+        qDebug("Port protection event handling not implemented");
         break;
     case WFD_EVENT_PIPELINE_BIND_SOURCE_COMPLETE:
         handlePipelineBindSourceComplete();
         break;
     case WFD_EVENT_PIPELINE_BIND_MASK_COMPLETE:
-        qDebug() << "Pipeline bind mask event handling not implemented";
+        qDebug("Pipeline bind mask event handling not implemented");
         break;
     default:
-        qDebug() << "Not recognised event type";
+        qDebug("Unrecognized event type: %lu", static_cast<long unsigned int>(type));
         break;
     }
 
@@ -206,10 +206,10 @@ void QOpenWFDDevice::readEvents(WFDtime wait)
 void QOpenWFDDevice::initializeGbmAndEgl()
 {
 
-    qDebug() << "initializing GBM and EGL";
+    qDebug("initializing GBM and EGL");
     int fd = wfdGetDeviceAttribi(mDevice,WFD_DEVICE_ID);
     if (fd < 0) {
-        qDebug() << "failed to get WFD_DEVICE_ID";
+        qDebug("failed to get WFD_DEVICE_ID");
     }
 
     mGbmDevice = gbm_create_device(fd);
@@ -221,12 +221,12 @@ void QOpenWFDDevice::initializeGbmAndEgl()
     EGLint minor, major;
 
     if (!eglInitialize(mEglDisplay,&major,&minor)) {
-        qDebug() << "failed to initialize egl";
+        qDebug("failed to initialize egl");
     }
 
     QByteArray eglExtensions = eglQueryString(mEglDisplay, EGL_EXTENSIONS);
     if (!eglExtensions.contains("EGL_KHR_surfaceless_opengl")) {
-        qDebug() << "This egl implementation does not have the required EGL extension EGL_KHR_surfaceless_opengl";
+        qDebug("This egl implementation does not have the required EGL extension EGL_KHR_surfaceless_opengl");
     }
 
     eglBindAPI(EGL_OPENGL_ES_API);
@@ -238,7 +238,7 @@ void QOpenWFDDevice::initializeGbmAndEgl()
 
     mEglContext = eglCreateContext(mEglDisplay,NULL,EGL_NO_CONTEXT,contextAttribs);
     if (mEglContext == EGL_NO_CONTEXT) {
-        qDebug() << "Failed to create EGL context";
+        qDebug("Failed to create EGL context");
     }
 
     eglCreateImage = (PFNEGLCREATEIMAGEKHRPROC) eglGetProcAddress("eglCreateImageKHR");
@@ -269,7 +269,7 @@ void QOpenWFDDevice::handlePortAttachDetach()
         for (int i = 0; i < mPorts.size(); i++) {
             if (mPorts.at(i)->portId() == id) {
                 indexToAdd = i;
-                qDebug() << "found index to attach";
+                qDebug("found index to attach");
                 break;
             }
         }
@@ -301,7 +301,7 @@ void QOpenWFDDevice::handlePipelineBindSourceComplete()
 
     WFDint overflow = wfdGetEventAttribi(mDevice,mEvent, WFD_EVENT_PIPELINE_BIND_QUEUE_OVERFLOW);
     if (overflow == WFD_TRUE) {
-        qDebug() << "PIPELINE_BIND_QUEUE_OVERFLOW event occurred";
+        qDebug("PIPELINE_BIND_QUEUE_OVERFLOW event occurred");
     }
 
     WFDint pipelineId = wfdGetEventAttribi(mDevice,mEvent,WFD_EVENT_PIPELINE_BIND_PIPELINE_ID);
diff --git a/src/plugins/platforms/openwfd/qopenwfdglcontext.cpp b/src/plugins/platforms/openwfd/qopenwfdglcontext.cpp
index d76c56db654..cf267ea2032 100644
--- a/src/plugins/platforms/openwfd/qopenwfdglcontext.cpp
+++ b/src/plugins/platforms/openwfd/qopenwfdglcontext.cpp
@@ -41,6 +41,7 @@
 
 #include "qopenwfdwindow.h"
 #include "qopenwfdscreen.h"
+#include <dlfcn.h>
 
 QOpenWFDGLContext::QOpenWFDGLContext(QOpenWFDDevice *device)
     : QPlatformOpenGLContext()
@@ -60,7 +61,7 @@ bool QOpenWFDGLContext::makeCurrent(QPlatformSurface *surface)
     EGLDisplay display = mWfdDevice->eglDisplay();
     EGLContext context = mWfdDevice->eglContext();
     if (!eglMakeCurrent(display,EGL_NO_SURFACE,EGL_NO_SURFACE,context)) {
-        qDebug() << "GLContext: eglMakeCurrent FAILED!";
+        qDebug("GLContext: eglMakeCurrent FAILED!");
     }
 
     QPlatformWindow *window = static_cast<QPlatformWindow *>(surface);
@@ -84,9 +85,12 @@ void QOpenWFDGLContext::swapBuffers(QPlatformSurface *surface)
     screen->swapBuffers();
 }
 
-void (*QOpenWFDGLContext::getProcAddress(const QByteArray &procName)) ()
+QFunctionPointer QOpenWFDGLContext::getProcAddress(const char *procName)
 {
-    return eglGetProcAddress(procName.data());
+    QFunctionPointer proc = (QFunctionPointer) eglGetProcAddress(procName);
+    if (!proc)
+        proc = (QFunctionPointer) dlsym(RTLD_DEFAULT, procName);
+    return proc;
 }
 
 EGLContext QOpenWFDGLContext::eglContext() const
diff --git a/src/plugins/platforms/openwfd/qopenwfdglcontext.h b/src/plugins/platforms/openwfd/qopenwfdglcontext.h
index 7b5a003253d..1c2541e098b 100644
--- a/src/plugins/platforms/openwfd/qopenwfdglcontext.h
+++ b/src/plugins/platforms/openwfd/qopenwfdglcontext.h
@@ -56,7 +56,7 @@ public:
 
     void swapBuffers(QPlatformSurface *surface);
 
-    void (*getProcAddress(const QByteArray &procName)) ();
+    QFunctionPointer getProcAddress(const char *procName);
 
     EGLContext eglContext() const;
 private:
diff --git a/src/plugins/platforms/openwfd/qopenwfdintegration.cpp b/src/plugins/platforms/openwfd/qopenwfdintegration.cpp
index 26fc93fc119..71e2b381fc5 100644
--- a/src/plugins/platforms/openwfd/qopenwfdintegration.cpp
+++ b/src/plugins/platforms/openwfd/qopenwfdintegration.cpp
@@ -79,7 +79,7 @@ QOpenWFDIntegration::QOpenWFDIntegration()
 QOpenWFDIntegration::~QOpenWFDIntegration()
 {
     //don't delete screens since they are deleted by the devices
-    qDebug() << "deleting platform integration";
+    qDebug("deleting platform integration");
     for (int i = 0; i < mDevices.size(); i++) {
         delete mDevices[i];
     }
diff --git a/src/plugins/platforms/openwfd/qopenwfdoutputbuffer.cpp b/src/plugins/platforms/openwfd/qopenwfdoutputbuffer.cpp
index dc560b98da5..4d0de7b0d45 100644
--- a/src/plugins/platforms/openwfd/qopenwfdoutputbuffer.cpp
+++ b/src/plugins/platforms/openwfd/qopenwfdoutputbuffer.cpp
@@ -69,7 +69,7 @@ QOpenWFDOutputBuffer::~QOpenWFDOutputBuffer()
 {
     wfdDestroySource(mPort->device()->handle(),mWfdSource);
     if (!mPort->device()->eglDestroyImage(mPort->device()->eglDisplay(),mEglImage)) {
-        qDebug() << "could not delete eglImage";
+        qDebug("could not delete eglImage");
     }
     gbm_bo_destroy(mGbm_buffer);
 
@@ -83,6 +83,6 @@ void QOpenWFDOutputBuffer::bindToCurrentFbo()
                               GL_RENDERBUFFER,
                               mRbo);
     if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE) {
-        qDebug() << "framebuffer not ready!";
+        qDebug("framebuffer not ready!");
     }
 }
diff --git a/src/plugins/platforms/openwfd/qopenwfdport.cpp b/src/plugins/platforms/openwfd/qopenwfdport.cpp
index 73d1fb99e78..33254fe83c3 100644
--- a/src/plugins/platforms/openwfd/qopenwfdport.cpp
+++ b/src/plugins/platforms/openwfd/qopenwfdport.cpp
@@ -80,7 +80,7 @@ void QOpenWFDPort::attach()
     Q_ASSERT(actualNumberOfPortModes == numberOfPortModes);
 
     if (!actualNumberOfPortModes) {
-        qDebug() << "didn't find any available port modes";
+        qDebug("didn't find any available port modes");
         return;
     }
 
@@ -94,7 +94,7 @@ void QOpenWFDPort::attach()
 
     mPixelSize = setNativeResolutionMode();
     if (mPixelSize.isEmpty()) {
-        qDebug() << "Could not set native resolution mode in QOpenWFPort";
+        qDebug("Could not set native resolution mode in QOpenWFPort");
     }
 
     WFDfloat physicalWFDSize[2];
diff --git a/src/plugins/platforms/openwfd/qopenwfdscreen.cpp b/src/plugins/platforms/openwfd/qopenwfdscreen.cpp
index f8a61dbb686..ab394fa594e 100644
--- a/src/plugins/platforms/openwfd/qopenwfdscreen.cpp
+++ b/src/plugins/platforms/openwfd/qopenwfdscreen.cpp
@@ -65,7 +65,7 @@ QOpenWFDScreen::QOpenWFDScreen(QOpenWFDPort *port)
     EGLContext context = mPort->device()->eglContext();
 
     if (!eglMakeCurrent(display,EGL_NO_SURFACE,EGL_NO_SURFACE,context)) {
-        qDebug() << "screen: eglMakeCurrent FAILED";
+        qDebug("screen: eglMakeCurrent FAILED");
     }
 
     glGenFramebuffers(1,&mFbo);
diff --git a/src/plugins/platforms/qnx/qqnxbuttoneventnotifier.cpp b/src/plugins/platforms/qnx/qqnxbuttoneventnotifier.cpp
index d07c6197528..a08ac2b8392 100644
--- a/src/plugins/platforms/qnx/qqnxbuttoneventnotifier.cpp
+++ b/src/plugins/platforms/qnx/qqnxbuttoneventnotifier.cpp
@@ -162,7 +162,7 @@ void QQnxButtonEventNotifier::updateButtonStates()
                     break;
 
                 default:
-                    qButtonDebug() << "Unknown hardware button";
+                    qButtonDebug("Unknown hardware button");
                     continue;
             }
 
diff --git a/src/plugins/platforms/qnx/qqnxglcontext.cpp b/src/plugins/platforms/qnx/qqnxglcontext.cpp
index 8207de4cbef..0d3076a743f 100644
--- a/src/plugins/platforms/qnx/qqnxglcontext.cpp
+++ b/src/plugins/platforms/qnx/qqnxglcontext.cpp
@@ -252,7 +252,7 @@ void QQnxGLContext::swapBuffers(QPlatformSurface *surface)
     platformWindow->swapEGLBuffers();
 }
 
-QFunctionPointer QQnxGLContext::getProcAddress(const QByteArray &procName)
+QFunctionPointer QQnxGLContext::getProcAddress(const char *procName)
 {
     qGLContextDebug();
 
@@ -262,7 +262,7 @@ QFunctionPointer QQnxGLContext::getProcAddress(const QByteArray &procName)
         qFatal("QQNX: failed to set EGL API, err=%d", eglGetError());
 
     // Lookup EGL extension function pointer
-    return static_cast<QFunctionPointer>(eglGetProcAddress(procName.constData()));
+    return static_cast<QFunctionPointer>(eglGetProcAddress(procName));
 }
 
 bool QQnxGLContext::isSharing() const
diff --git a/src/plugins/platforms/qnx/qqnxglcontext.h b/src/plugins/platforms/qnx/qqnxglcontext.h
index 897dbefc38b..74cd3b4c48e 100644
--- a/src/plugins/platforms/qnx/qqnxglcontext.h
+++ b/src/plugins/platforms/qnx/qqnxglcontext.h
@@ -67,7 +67,7 @@ public:
     bool makeCurrent(QPlatformSurface *surface);
     void doneCurrent();
     void swapBuffers(QPlatformSurface *surface);
-    QFunctionPointer getProcAddress(const QByteArray &procName);
+    QFunctionPointer getProcAddress(const char *procName);
 
     virtual QSurfaceFormat format() const { return m_windowFormat; }
     bool isSharing() const;
diff --git a/src/plugins/platforms/qnx/qqnxinputcontext_imf.cpp b/src/plugins/platforms/qnx/qqnxinputcontext_imf.cpp
index 64f38265f69..79ff74b1132 100644
--- a/src/plugins/platforms/qnx/qqnxinputcontext_imf.cpp
+++ b/src/plugins/platforms/qnx/qqnxinputcontext_imf.cpp
@@ -385,7 +385,7 @@ static int32_t ic_perform_editor_action(input_session_t *ic, int32_t editor_acti
     Q_UNUSED(ic);
     Q_UNUSED(editor_action);
 
-    qCritical() << "ic_perform_editor_action not implemented";
+    qCritical("ic_perform_editor_action not implemented");
     return 0;
 }
 
@@ -395,7 +395,7 @@ static int32_t ic_report_fullscreen_mode(input_session_t *ic, int32_t enabled)
     Q_UNUSED(ic);
     Q_UNUSED(enabled);
 
-    qCritical() << "ic_report_fullscreen_mode not implemented";
+    qCritical("ic_report_fullscreen_mode not implemented");
     return 0;
 }
 
@@ -406,7 +406,7 @@ static extracted_text_t *ic_get_extracted_text(input_session_t *ic, extracted_te
     Q_UNUSED(request);
     Q_UNUSED(flags);
 
-    qCritical() << "ic_get_extracted_text not implemented";
+    qCritical("ic_get_extracted_text not implemented");
     return 0;
 }
 
@@ -416,7 +416,7 @@ static spannable_string_t *ic_get_selected_text(input_session_t *ic, int32_t fla
     Q_UNUSED(ic);
     Q_UNUSED(flags);
 
-    qCritical() << "ic_get_selected_text not implemented";
+    qCritical("ic_get_selected_text not implemented");
     return 0;
 }
 
@@ -426,7 +426,7 @@ static int32_t ic_get_cursor_caps_mode(input_session_t *ic, int32_t req_modes)
     Q_UNUSED(ic);
     Q_UNUSED(req_modes);
 
-    qCritical() << "ic_get_cursor_caps_mode not implemented";
+    qCritical("ic_get_cursor_caps_mode not implemented");
     return 0;
 }
 
@@ -436,7 +436,7 @@ static int32_t ic_clear_meta_key_states(input_session_t *ic, int32_t states)
     Q_UNUSED(ic);
     Q_UNUSED(states);
 
-    qCritical() << "ic_clear_meta_key_states not implemented";
+    qCritical("ic_clear_meta_key_states not implemented");
     return 0;
 }
 
@@ -447,7 +447,7 @@ static int32_t ic_set_selection(input_session_t *ic, int32_t start, int32_t end)
     Q_UNUSED(start);
     Q_UNUSED(end);
 
-    qCritical() << "ic_set_selection not implemented";
+    qCritical("ic_set_selection not implemented");
     return 0;
 }
 
diff --git a/src/plugins/platforms/qnx/qqnxscreeneventhandler.cpp b/src/plugins/platforms/qnx/qqnxscreeneventhandler.cpp
index 261c8e8773a..599d43a8c85 100644
--- a/src/plugins/platforms/qnx/qqnxscreeneventhandler.cpp
+++ b/src/plugins/platforms/qnx/qqnxscreeneventhandler.cpp
@@ -553,7 +553,7 @@ void QQnxScreenEventHandler::handleDisplayEvent(screen_event_t event)
             if (val[0] == 0 && val[1] == 0) //If screen size is invalid, wait for the next event
                 return;
 
-            qScreenEventDebug() << "creating new QQnxScreen for newly attached display";
+            qScreenEventDebug("creating new QQnxScreen for newly attached display");
             m_qnxIntegration->createDisplay(nativeDisplay, false /* not primary, we assume */);
         }
     } else if (!isAttached) {
@@ -566,7 +566,7 @@ void QQnxScreenEventHandler::handleDisplayEvent(screen_event_t event)
 
         if (!screen->isPrimaryScreen()) {
             // libscreen display is deactivated, let's remove the QQnxScreen / QScreen
-            qScreenEventDebug() << "removing display";
+            qScreenEventDebug("removing display");
             m_qnxIntegration->removeDisplay(screen);
         }
     }
diff --git a/src/plugins/platforms/qnx/qqnxwindow.cpp b/src/plugins/platforms/qnx/qqnxwindow.cpp
index 9d591286c02..e04f16db929 100644
--- a/src/plugins/platforms/qnx/qqnxwindow.cpp
+++ b/src/plugins/platforms/qnx/qqnxwindow.cpp
@@ -475,7 +475,7 @@ void QQnxWindow::setParent(const QPlatformWindow *window)
         return;
 
     if (screen()->rootWindow() == this) {
-        qWarning() << "Application window cannot be reparented";
+        qWarning("Application window cannot be reparented");
         return;
     }
 
diff --git a/src/plugins/platforms/windows/openglblacklists/default.json b/src/plugins/platforms/windows/openglblacklists/default.json
index 767eac161cb..f7a88446111 100644
--- a/src/plugins/platforms/windows/openglblacklists/default.json
+++ b/src/plugins/platforms/windows/openglblacklists/default.json
@@ -78,6 +78,18 @@
            "features": [
                "disable_rotation"
            ]
+        },
+        {
+           "id": 7,
+           "description": "AMD FirePro V5900 driver causes crashes in Direct3D on Windows.",
+           "vendor_id": "0x1002",
+           "device_id": ["0x6707"],
+           "os": {
+               "type": "win"
+           },
+           "features": [
+               "disable_angle"
+           ]
         }
     ]
 }
diff --git a/src/plugins/platforms/windows/qwindowsdialoghelpers.cpp b/src/plugins/platforms/windows/qwindowsdialoghelpers.cpp
index 72d9d5a71b0..0eab37aed2d 100644
--- a/src/plugins/platforms/windows/qwindowsdialoghelpers.cpp
+++ b/src/plugins/platforms/windows/qwindowsdialoghelpers.cpp
@@ -1472,18 +1472,21 @@ public:
 };
 
 // Return the first suffix from the name filter "Foo files (*.foo;*.bar)" -> "foo".
+// Also handles the simple name filter case "*.txt" -> "txt"
 static inline QString suffixFromFilter(const QString &filter)
 {
-    int suffixPos = filter.indexOf(QLatin1String("(*."));
+    int suffixPos = filter.indexOf(QLatin1String("*."));
     if (suffixPos < 0)
         return QString();
-    suffixPos += 3;
+    suffixPos += 2;
     int endPos = filter.indexOf(QLatin1Char(' '), suffixPos + 1);
     if (endPos < 0)
         endPos = filter.indexOf(QLatin1Char(';'), suffixPos + 1);
     if (endPos < 0)
         endPos = filter.indexOf(QLatin1Char(')'), suffixPos + 1);
-    return endPos >= 0 ? filter.mid(suffixPos, endPos - suffixPos) : QString();
+    if (endPos < 0)
+        endPos = filter.size();
+    return filter.mid(suffixPos, endPos - suffixPos);
 }
 
 void QWindowsNativeSaveFileDialog::setNameFilters(const QStringList &f)
diff --git a/src/plugins/platforms/windows/qwindowseglcontext.cpp b/src/plugins/platforms/windows/qwindowseglcontext.cpp
index a11196d1d29..42caeb1c894 100644
--- a/src/plugins/platforms/windows/qwindowseglcontext.cpp
+++ b/src/plugins/platforms/windows/qwindowseglcontext.cpp
@@ -107,11 +107,7 @@ static void *resolveFunc(HMODULE lib, const char *name)
 
 void *QWindowsLibEGL::resolve(const char *name)
 {
-    void *proc = m_lib ? resolveFunc(m_lib, name) : 0;
-    if (!proc)
-        qErrnoWarning(::GetLastError(), "Failed to resolve EGL function %s", name);
-
-    return proc;
+    return m_lib ? resolveFunc(m_lib, name) : 0;
 }
 
 #endif // !QT_STATIC
@@ -174,11 +170,7 @@ bool QWindowsLibEGL::init()
 #if !defined(QT_STATIC) || defined(QT_OPENGL_DYNAMIC)
 void *QWindowsLibGLESv2::resolve(const char *name)
 {
-    void *proc = m_lib ? resolveFunc(m_lib, name) : 0;
-    if (!proc)
-        qWarning() << "Failed to resolve OpenGL ES function" << name;
-
-    return proc;
+    return m_lib ? resolveFunc(m_lib, name) : 0;
 }
 #endif // !QT_STATIC
 
@@ -200,150 +192,10 @@ bool QWindowsLibGLESv2::init()
     }
 #endif // !QT_STATIC
 
-    glBindTexture = RESOLVE((void (APIENTRY *)(GLenum , GLuint )), glBindTexture);
-    glBlendFunc = RESOLVE((void (APIENTRY *)(GLenum , GLenum )), glBlendFunc);
-    glClear = RESOLVE((void (APIENTRY *)(GLbitfield )), glClear);
-    glClearColor = RESOLVE((void (APIENTRY *)(GLfloat , GLfloat , GLfloat , GLfloat )), glClearColor);
-    glClearStencil = RESOLVE((void (APIENTRY *)(GLint )), glClearStencil);
-    glColorMask = RESOLVE((void (APIENTRY *)(GLboolean , GLboolean , GLboolean , GLboolean )), glColorMask);
-    glCopyTexImage2D = RESOLVE((void (APIENTRY *)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint )), glCopyTexImage2D);
-    glCopyTexSubImage2D = RESOLVE((void (APIENTRY *)(GLenum , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei )), glCopyTexSubImage2D);
-    glCullFace = RESOLVE((void (APIENTRY *)(GLenum )), glCullFace);
-    glDeleteTextures = RESOLVE((void (APIENTRY *)(GLsizei , const GLuint *)), glDeleteTextures);
-    glDepthFunc = RESOLVE((void (APIENTRY *)(GLenum )), glDepthFunc);
-    glDepthMask = RESOLVE((void (APIENTRY *)(GLboolean )), glDepthMask);
-    glDisable = RESOLVE((void (APIENTRY *)(GLenum )), glDisable);
-    glDrawArrays = RESOLVE((void (APIENTRY *)(GLenum , GLint , GLsizei )), glDrawArrays);
-    glDrawElements = RESOLVE((void (APIENTRY *)(GLenum , GLsizei , GLenum , const GLvoid *)), glDrawElements);
-    glEnable = RESOLVE((void (APIENTRY *)(GLenum )), glEnable);
-    glFinish = RESOLVE((void (APIENTRY *)()), glFinish);
-    glFlush = RESOLVE((void (APIENTRY *)()), glFlush);
-    glFrontFace = RESOLVE((void (APIENTRY *)(GLenum )), glFrontFace);
-    glGenTextures = RESOLVE((void (APIENTRY *)(GLsizei , GLuint *)), glGenTextures);
-    glGetBooleanv = RESOLVE((void (APIENTRY *)(GLenum , GLboolean *)), glGetBooleanv);
-    glGetError = RESOLVE((GLenum (APIENTRY *)()), glGetError);
-    glGetFloatv = RESOLVE((void (APIENTRY *)(GLenum , GLfloat *)), glGetFloatv);
-    glGetIntegerv = RESOLVE((void (APIENTRY *)(GLenum , GLint *)), glGetIntegerv);
+    void (APIENTRY * glBindTexture)(GLenum target, GLuint texture) = RESOLVE((void (APIENTRY *)(GLenum , GLuint )), glBindTexture);
+    GLuint (APIENTRY * glCreateShader)(GLenum type) = RESOLVE((GLuint (APIENTRY *)(GLenum )), glCreateShader);
+    void (APIENTRY * glClearDepthf)(GLclampf depth) = RESOLVE((void (APIENTRY *)(GLclampf )), glClearDepthf);
     glGetString = RESOLVE((const GLubyte * (APIENTRY *)(GLenum )), glGetString);
-    glGetTexParameterfv = RESOLVE((void (APIENTRY *)(GLenum , GLenum , GLfloat *)), glGetTexParameterfv);
-    glGetTexParameteriv = RESOLVE((void (APIENTRY *)(GLenum , GLenum , GLint *)), glGetTexParameteriv);
-    glHint = RESOLVE((void (APIENTRY *)(GLenum , GLenum )), glHint);
-    glIsEnabled = RESOLVE((GLboolean (APIENTRY *)(GLenum )), glIsEnabled);
-    glIsTexture = RESOLVE((GLboolean (APIENTRY *)(GLuint )), glIsTexture);
-    glLineWidth = RESOLVE((void (APIENTRY *)(GLfloat )), glLineWidth);
-    glPixelStorei = RESOLVE((void (APIENTRY *)(GLenum , GLint )), glPixelStorei);
-    glPolygonOffset = RESOLVE((void (APIENTRY *)(GLfloat , GLfloat )), glPolygonOffset);
-    glReadPixels = RESOLVE((void (APIENTRY *)(GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , GLvoid *)), glReadPixels);
-    glScissor = RESOLVE((void (APIENTRY *)(GLint , GLint , GLsizei , GLsizei )), glScissor);
-    glStencilFunc = RESOLVE((void (APIENTRY *)(GLenum , GLint , GLuint )), glStencilFunc);
-    glStencilMask = RESOLVE((void (APIENTRY *)(GLuint )), glStencilMask);
-    glStencilOp = RESOLVE((void (APIENTRY *)(GLenum , GLenum , GLenum )), glStencilOp);
-    glTexImage2D = RESOLVE((void (APIENTRY *)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)), glTexImage2D);
-    glTexParameterf = RESOLVE((void (APIENTRY *)(GLenum , GLenum , GLfloat )), glTexParameterf);
-    glTexParameterfv = RESOLVE((void (APIENTRY *)(GLenum , GLenum , const GLfloat *)), glTexParameterfv);
-    glTexParameteri = RESOLVE((void (APIENTRY *)(GLenum , GLenum , GLint )), glTexParameteri);
-    glTexParameteriv = RESOLVE((void (APIENTRY *)(GLenum , GLenum , const GLint *)), glTexParameteriv);
-    glTexSubImage2D = RESOLVE((void (APIENTRY *)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)), glTexSubImage2D);
-    glViewport = RESOLVE((void (APIENTRY *)(GLint , GLint , GLsizei , GLsizei )), glViewport);
-
-    glActiveTexture = RESOLVE((void (APIENTRY *)(GLenum)), glActiveTexture);
-    glAttachShader = RESOLVE((void (APIENTRY *)(GLuint , GLuint )), glAttachShader);
-    glBindAttribLocation = RESOLVE((void (APIENTRY *)(GLuint , GLuint , const GLchar* )), glBindAttribLocation);
-    glBindBuffer = RESOLVE((void (APIENTRY *)(GLenum , GLuint )), glBindBuffer);
-    glBindFramebuffer = RESOLVE((void (APIENTRY *)(GLenum , GLuint )), glBindFramebuffer);
-    glBindRenderbuffer = RESOLVE((void (APIENTRY *)(GLenum , GLuint )), glBindRenderbuffer);
-    glBlendColor = RESOLVE((void (APIENTRY *)(GLclampf , GLclampf , GLclampf , GLclampf )), glBlendColor);
-    glBlendEquation = RESOLVE((void (APIENTRY *)(GLenum )), glBlendEquation);
-    glBlendEquationSeparate = RESOLVE((void (APIENTRY *)(GLenum , GLenum )), glBlendEquationSeparate);
-    glBlendFuncSeparate = RESOLVE((void (APIENTRY *)(GLenum , GLenum , GLenum , GLenum )), glBlendFuncSeparate);
-    glBufferData = RESOLVE((void (APIENTRY *)(GLenum , qopengl_GLsizeiptr , const GLvoid* , GLenum )), glBufferData);
-    glBufferSubData = RESOLVE((void (APIENTRY *)(GLenum , qopengl_GLintptr , qopengl_GLsizeiptr , const GLvoid* )), glBufferSubData);
-    glCheckFramebufferStatus = RESOLVE((GLenum (APIENTRY *)(GLenum )), glCheckFramebufferStatus);
-    glCompileShader = RESOLVE((void (APIENTRY *)(GLuint )), glCompileShader);
-    glCompressedTexImage2D = RESOLVE((void (APIENTRY *)(GLenum , GLint , GLenum , GLsizei , GLsizei, GLint, GLsizei, const GLvoid* )), glCompressedTexImage2D);
-    glCompressedTexSubImage2D = RESOLVE((void (APIENTRY *)(GLenum , GLint , GLint , GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid* )), glCompressedTexSubImage2D);
-    glCreateProgram = RESOLVE((GLuint (APIENTRY *)(void)), glCreateProgram);
-    glCreateShader = RESOLVE((GLuint (APIENTRY *)(GLenum )), glCreateShader);
-    glDeleteBuffers = RESOLVE((void (APIENTRY *)(GLsizei , const GLuint*)), glDeleteBuffers);
-    glDeleteFramebuffers = RESOLVE((void (APIENTRY *)(GLsizei , const GLuint* )), glDeleteFramebuffers);
-    glDeleteProgram = RESOLVE((void (APIENTRY *)(GLuint )), glDeleteProgram);
-    glDeleteRenderbuffers = RESOLVE((void (APIENTRY *)(GLsizei , const GLuint* )), glDeleteRenderbuffers);
-    glDeleteShader = RESOLVE((void (APIENTRY *)(GLuint )), glDeleteShader);
-    glDetachShader = RESOLVE((void (APIENTRY *)(GLuint , GLuint )), glDetachShader);
-    glDisableVertexAttribArray = RESOLVE((void (APIENTRY *)(GLuint )), glDisableVertexAttribArray);
-    glEnableVertexAttribArray = RESOLVE((void (APIENTRY *)(GLuint )), glEnableVertexAttribArray);
-    glFramebufferRenderbuffer = RESOLVE((void (APIENTRY *)(GLenum , GLenum , GLenum , GLuint )), glFramebufferRenderbuffer);
-    glFramebufferTexture2D = RESOLVE((void (APIENTRY *)(GLenum , GLenum , GLenum , GLuint , GLint )), glFramebufferTexture2D);
-    glGenBuffers = RESOLVE((void (APIENTRY *)(GLsizei , GLuint* )), glGenBuffers);
-    glGenerateMipmap = RESOLVE((void (APIENTRY *)(GLenum )), glGenerateMipmap);
-    glGenFramebuffers = RESOLVE((void (APIENTRY *)(GLsizei , GLuint* )), glGenFramebuffers);
-    glGenRenderbuffers = RESOLVE((void (APIENTRY *)(GLsizei , GLuint* )), glGenRenderbuffers);
-    glGetActiveAttrib = RESOLVE((void (APIENTRY *)(GLuint , GLuint , GLsizei , GLsizei* , GLint* , GLenum* , GLchar* )), glGetActiveAttrib);
-    glGetActiveUniform = RESOLVE((void (APIENTRY *)(GLuint , GLuint , GLsizei , GLsizei* , GLint* , GLenum* , GLchar* )), glGetActiveUniform);
-    glGetAttachedShaders = RESOLVE((void (APIENTRY *)(GLuint , GLsizei , GLsizei*, GLuint* )), glGetAttachedShaders);
-    glGetAttribLocation = RESOLVE((int (APIENTRY *)(GLuint , const GLchar* )), glGetAttribLocation);
-    glGetBufferParameteriv = RESOLVE((void (APIENTRY *)(GLenum , GLenum , GLint* )), glGetBufferParameteriv);
-    glGetFramebufferAttachmentParameteriv = RESOLVE((void (APIENTRY *)(GLenum , GLenum, GLenum , GLint* )), glGetFramebufferAttachmentParameteriv);
-    glGetProgramiv = RESOLVE((void (APIENTRY *)(GLuint , GLenum , GLint* )), glGetProgramiv);
-    glGetProgramInfoLog = RESOLVE((void (APIENTRY *)(GLuint , GLsizei , GLsizei* , GLchar* )), glGetProgramInfoLog);
-    glGetRenderbufferParameteriv = RESOLVE((void (APIENTRY *)(GLenum , GLenum , GLint* )), glGetRenderbufferParameteriv);
-    glGetShaderiv = RESOLVE((void (APIENTRY *)(GLuint , GLenum , GLint* )), glGetShaderiv);
-    glGetShaderInfoLog = RESOLVE((void (APIENTRY *)(GLuint , GLsizei , GLsizei*, GLchar*)), glGetShaderInfoLog);
-    glGetShaderPrecisionFormat = RESOLVE((void (APIENTRY *)(GLenum , GLenum , GLint* , GLint* )), glGetShaderPrecisionFormat);
-    glGetShaderSource = RESOLVE((void (APIENTRY *)(GLuint , GLsizei , GLsizei* , GLchar* )), glGetShaderSource);
-    glGetUniformfv = RESOLVE((void (APIENTRY *)(GLuint , GLint , GLfloat*)), glGetUniformfv);
-    glGetUniformiv = RESOLVE((void (APIENTRY *)(GLuint , GLint , GLint*)), glGetUniformiv);
-    glGetUniformLocation = RESOLVE((int (APIENTRY *)(GLuint , const GLchar* )), glGetUniformLocation);
-    glGetVertexAttribfv = RESOLVE((void (APIENTRY *)(GLuint , GLenum , GLfloat* )), glGetVertexAttribfv);
-    glGetVertexAttribiv = RESOLVE((void (APIENTRY *)(GLuint , GLenum , GLint* )), glGetVertexAttribiv);
-    glGetVertexAttribPointerv = RESOLVE((void (APIENTRY *)(GLuint , GLenum , GLvoid** pointer)), glGetVertexAttribPointerv);
-    glIsBuffer = RESOLVE((GLboolean (APIENTRY *)(GLuint )), glIsBuffer);
-    glIsFramebuffer = RESOLVE((GLboolean (APIENTRY *)(GLuint )), glIsFramebuffer);
-    glIsProgram = RESOLVE((GLboolean (APIENTRY *)(GLuint )), glIsProgram);
-    glIsRenderbuffer = RESOLVE((GLboolean (APIENTRY *)(GLuint )), glIsRenderbuffer);
-    glIsShader = RESOLVE((GLboolean (APIENTRY *)(GLuint )), glIsShader);
-    glLinkProgram = RESOLVE((void (APIENTRY *)(GLuint )), glLinkProgram);
-    glReleaseShaderCompiler = RESOLVE((void (APIENTRY *)(void)), glReleaseShaderCompiler);
-    glRenderbufferStorage = RESOLVE((void (APIENTRY *)(GLenum , GLenum , GLsizei , GLsizei )), glRenderbufferStorage);
-    glSampleCoverage = RESOLVE((void (APIENTRY *)(GLclampf , GLboolean )), glSampleCoverage);
-    glShaderBinary = RESOLVE((void (APIENTRY *)(GLsizei , const GLuint*, GLenum , const GLvoid* , GLsizei )), glShaderBinary);
-    glShaderSource = RESOLVE((void (APIENTRY *)(GLuint , GLsizei , const GLchar* *, const GLint* )), glShaderSource);
-    glStencilFuncSeparate = RESOLVE((void (APIENTRY *)(GLenum , GLenum , GLint , GLuint )), glStencilFuncSeparate);
-    glStencilMaskSeparate = RESOLVE((void (APIENTRY *)(GLenum , GLuint )), glStencilMaskSeparate);
-    glStencilOpSeparate = RESOLVE((void (APIENTRY *)(GLenum , GLenum , GLenum , GLenum )), glStencilOpSeparate);
-    glUniform1f = RESOLVE((void (APIENTRY *)(GLint , GLfloat )), glUniform1f);
-    glUniform1fv = RESOLVE((void (APIENTRY *)(GLint , GLsizei , const GLfloat* )), glUniform1fv);
-    glUniform1i = RESOLVE((void (APIENTRY *)(GLint , GLint )), glUniform1i);
-    glUniform1iv = RESOLVE((void (APIENTRY *)(GLint , GLsizei , const GLint* )), glUniform1iv);
-    glUniform2f = RESOLVE((void (APIENTRY *)(GLint , GLfloat , GLfloat )), glUniform2f);
-    glUniform2fv = RESOLVE((void (APIENTRY *)(GLint , GLsizei , const GLfloat* )), glUniform2fv);
-    glUniform2i = RESOLVE((void (APIENTRY *)(GLint , GLint , GLint )), glUniform2i);
-    glUniform2iv = RESOLVE((void (APIENTRY *)(GLint , GLsizei , const GLint* )), glUniform2iv);
-    glUniform3f = RESOLVE((void (APIENTRY *)(GLint , GLfloat , GLfloat , GLfloat )), glUniform3f);
-    glUniform3fv = RESOLVE((void (APIENTRY *)(GLint , GLsizei , const GLfloat* )), glUniform3fv);
-    glUniform3i = RESOLVE((void (APIENTRY *)(GLint , GLint , GLint , GLint )), glUniform3i);
-    glUniform3iv = RESOLVE((void (APIENTRY *)(GLint , GLsizei , const GLint* )), glUniform3iv);
-    glUniform4f = RESOLVE((void (APIENTRY *)(GLint , GLfloat , GLfloat , GLfloat , GLfloat )), glUniform4f);
-    glUniform4fv = RESOLVE((void (APIENTRY *)(GLint , GLsizei , const GLfloat* )), glUniform4fv);
-    glUniform4i = RESOLVE((void (APIENTRY *)(GLint , GLint , GLint , GLint , GLint )), glUniform4i);
-    glUniform4iv = RESOLVE((void (APIENTRY *)(GLint , GLsizei , const GLint* )), glUniform4iv);
-    glUniformMatrix2fv = RESOLVE((void (APIENTRY *)(GLint , GLsizei , GLboolean , const GLfloat* )), glUniformMatrix2fv);
-    glUniformMatrix3fv = RESOLVE((void (APIENTRY *)(GLint , GLsizei , GLboolean , const GLfloat* )), glUniformMatrix3fv);
-    glUniformMatrix4fv = RESOLVE((void (APIENTRY *)(GLint , GLsizei , GLboolean , const GLfloat* )), glUniformMatrix4fv);
-    glUseProgram = RESOLVE((void (APIENTRY *)(GLuint )), glUseProgram);
-    glValidateProgram = RESOLVE((void (APIENTRY *)(GLuint )), glValidateProgram);
-    glVertexAttrib1f = RESOLVE((void (APIENTRY *)(GLuint , GLfloat )), glVertexAttrib1f);
-    glVertexAttrib1fv = RESOLVE((void (APIENTRY *)(GLuint , const GLfloat* )), glVertexAttrib1fv);
-    glVertexAttrib2f = RESOLVE((void (APIENTRY *)(GLuint , GLfloat , GLfloat )), glVertexAttrib2f);
-    glVertexAttrib2fv = RESOLVE((void (APIENTRY *)(GLuint , const GLfloat* )), glVertexAttrib2fv);
-    glVertexAttrib3f = RESOLVE((void (APIENTRY *)(GLuint , GLfloat , GLfloat , GLfloat )), glVertexAttrib3f);
-    glVertexAttrib3fv = RESOLVE((void (APIENTRY *)(GLuint , const GLfloat* )), glVertexAttrib3fv);
-    glVertexAttrib4f = RESOLVE((void (APIENTRY *)(GLuint , GLfloat , GLfloat , GLfloat , GLfloat )), glVertexAttrib4f);
-    glVertexAttrib4fv = RESOLVE((void (APIENTRY *)(GLuint , const GLfloat* )), glVertexAttrib4fv);
-    glVertexAttribPointer = RESOLVE((void (APIENTRY *)(GLuint , GLint, GLenum, GLboolean, GLsizei, const GLvoid* )), glVertexAttribPointer);
-
-    glClearDepthf = RESOLVE((void (APIENTRY *)(GLclampf )), glClearDepthf);
-    glDepthRangef = RESOLVE((void (APIENTRY *)(GLclampf , GLclampf )), glDepthRangef);
 
     return glBindTexture && glCreateShader && glClearDepthf;
 }
@@ -683,170 +535,192 @@ void QWindowsEGLContext::swapBuffers(QPlatformSurface *surface)
     }
 }
 
-QFunctionPointer QWindowsEGLContext::getProcAddress(const QByteArray &procName)
+QFunctionPointer QWindowsEGLContext::getProcAddress(const char *procName)
 {
+    QWindowsEGLStaticContext::libEGL.eglBindAPI(m_api);
+
+    QFunctionPointer procAddress = nullptr;
+
+    // Special logic for ANGLE extensions for blitFramebuffer and
+    // renderbufferStorageMultisample. In version 2 contexts the extensions
+    // must be used instead of the suffixless, version 3.0 functions.
+    if (m_format.majorVersion() < 3) {
+        if (!strcmp(procName, "glBlitFramebuffer") || !strcmp(procName, "glRenderbufferStorageMultisample")) {
+            char extName[32 + 5 + 1];
+            strcpy(extName, procName);
+            strcat(extName, "ANGLE");
+            procAddress = reinterpret_cast<QFunctionPointer>(QWindowsEGLStaticContext::libEGL.eglGetProcAddress(extName));
+        }
+    }
+
+    if (!procAddress)
+        procAddress = reinterpret_cast<QFunctionPointer>(QWindowsEGLStaticContext::libEGL.eglGetProcAddress(procName));
+
     // We support AllGLFunctionsQueryable, which means this function must be able to
     // return a function pointer for standard GLES2 functions too. These are not
     // guaranteed to be queryable via eglGetProcAddress().
-    static struct StdFunc {
-        const char *name;
-        void *func;
-    } standardFuncs[] = {
-        { "glBindTexture", (void *) QWindowsEGLStaticContext::libGLESv2.glBindTexture },
-        { "glBlendFunc", (void *) QWindowsEGLStaticContext::libGLESv2.glBlendFunc },
-        { "glClear", (void *) QWindowsEGLStaticContext::libGLESv2.glClear },
-        { "glClearColor", (void *) QWindowsEGLStaticContext::libGLESv2.glClearColor },
-        { "glClearStencil", (void *) QWindowsEGLStaticContext::libGLESv2.glClearStencil },
-        { "glColorMask", (void *) QWindowsEGLStaticContext::libGLESv2.glColorMask },
-        { "glCopyTexImage2D", (void *) QWindowsEGLStaticContext::libGLESv2.glCopyTexImage2D },
-        { "glCopyTexSubImage2D", (void *) QWindowsEGLStaticContext::libGLESv2.glCopyTexSubImage2D },
-        { "glCullFace", (void *) QWindowsEGLStaticContext::libGLESv2.glCullFace },
-        { "glDeleteTextures", (void *) QWindowsEGLStaticContext::libGLESv2.glDeleteTextures },
-        { "glDepthFunc", (void *) QWindowsEGLStaticContext::libGLESv2.glDepthFunc },
-        { "glDepthMask", (void *) QWindowsEGLStaticContext::libGLESv2.glDepthMask },
-        { "glDisable", (void *) QWindowsEGLStaticContext::libGLESv2.glDisable },
-        { "glDrawArrays", (void *) QWindowsEGLStaticContext::libGLESv2.glDrawArrays },
-        { "glDrawElements", (void *) QWindowsEGLStaticContext::libGLESv2.glDrawElements },
-        { "glEnable", (void *) QWindowsEGLStaticContext::libGLESv2.glEnable },
-        { "glFinish", (void *) QWindowsEGLStaticContext::libGLESv2.glFinish },
-        { "glFlush", (void *) QWindowsEGLStaticContext::libGLESv2.glFlush },
-        { "glFrontFace", (void *) QWindowsEGLStaticContext::libGLESv2.glFrontFace },
-        { "glGenTextures", (void *) QWindowsEGLStaticContext::libGLESv2.glGenTextures },
-        { "glGetBooleanv", (void *) QWindowsEGLStaticContext::libGLESv2.glGetBooleanv },
-        { "glGetError", (void *) QWindowsEGLStaticContext::libGLESv2.glGetError },
-        { "glGetFloatv", (void *) QWindowsEGLStaticContext::libGLESv2.glGetFloatv },
-        { "glGetIntegerv", (void *) QWindowsEGLStaticContext::libGLESv2.glGetIntegerv },
-        { "glGetString", (void *) QWindowsEGLStaticContext::libGLESv2.glGetString },
-        { "glGetTexParameterfv", (void *) QWindowsEGLStaticContext::libGLESv2.glGetTexParameterfv },
-        { "glGetTexParameteriv", (void *) QWindowsEGLStaticContext::libGLESv2.glGetTexParameteriv },
-        { "glHint", (void *) QWindowsEGLStaticContext::libGLESv2.glHint },
-        { "glIsEnabled", (void *) QWindowsEGLStaticContext::libGLESv2.glIsEnabled },
-        { "glIsTexture", (void *) QWindowsEGLStaticContext::libGLESv2.glIsTexture },
-        { "glLineWidth", (void *) QWindowsEGLStaticContext::libGLESv2.glLineWidth },
-        { "glPixelStorei", (void *) QWindowsEGLStaticContext::libGLESv2.glPixelStorei },
-        { "glPolygonOffset", (void *) QWindowsEGLStaticContext::libGLESv2.glPolygonOffset },
-        { "glReadPixels", (void *) QWindowsEGLStaticContext::libGLESv2.glReadPixels },
-        { "glScissor", (void *) QWindowsEGLStaticContext::libGLESv2.glScissor },
-        { "glStencilFunc", (void *) QWindowsEGLStaticContext::libGLESv2.glStencilFunc },
-        { "glStencilMask", (void *) QWindowsEGLStaticContext::libGLESv2.glStencilMask },
-        { "glStencilOp", (void *) QWindowsEGLStaticContext::libGLESv2.glStencilOp },
-        { "glTexImage2D", (void *) QWindowsEGLStaticContext::libGLESv2.glTexImage2D },
-        { "glTexParameterf", (void *) QWindowsEGLStaticContext::libGLESv2.glTexParameterf },
-        { "glTexParameterfv", (void *) QWindowsEGLStaticContext::libGLESv2.glTexParameterfv },
-        { "glTexParameteri", (void *) QWindowsEGLStaticContext::libGLESv2.glTexParameteri },
-        { "glTexParameteriv", (void *) QWindowsEGLStaticContext::libGLESv2.glTexParameteriv },
-        { "glTexSubImage2D", (void *) QWindowsEGLStaticContext::libGLESv2.glTexSubImage2D },
-        { "glViewport", (void *) QWindowsEGLStaticContext::libGLESv2.glViewport },
+    if (!procAddress) {
+#if defined(QT_STATIC)
+        static struct StdFunc {
+            const char *name;
+            void *func;
+        } standardFuncs[] = {
+            { "glBindTexture", (void *) ::glBindTexture },
+            { "glBlendFunc", (void *) ::glBlendFunc },
+            { "glClear", (void *) ::glClear },
+            { "glClearColor", (void *) ::glClearColor },
+            { "glClearStencil", (void *) ::glClearStencil },
+            { "glColorMask", (void *) ::glColorMask },
+            { "glCopyTexImage2D", (void *) ::glCopyTexImage2D },
+            { "glCopyTexSubImage2D", (void *) ::glCopyTexSubImage2D },
+            { "glCullFace", (void *) ::glCullFace },
+            { "glDeleteTextures", (void *) ::glDeleteTextures },
+            { "glDepthFunc", (void *) ::glDepthFunc },
+            { "glDepthMask", (void *) ::glDepthMask },
+            { "glDisable", (void *) ::glDisable },
+            { "glDrawArrays", (void *) ::glDrawArrays },
+            { "glDrawElements", (void *) ::glDrawElements },
+            { "glEnable", (void *) ::glEnable },
+            { "glFinish", (void *) ::glFinish },
+            { "glFlush", (void *) ::glFlush },
+            { "glFrontFace", (void *) ::glFrontFace },
+            { "glGenTextures", (void *) ::glGenTextures },
+            { "glGetBooleanv", (void *) ::glGetBooleanv },
+            { "glGetError", (void *) ::glGetError },
+            { "glGetFloatv", (void *) ::glGetFloatv },
+            { "glGetIntegerv", (void *) ::glGetIntegerv },
+            { "glGetString", (void *) ::glGetString },
+            { "glGetTexParameterfv", (void *) ::glGetTexParameterfv },
+            { "glGetTexParameteriv", (void *) ::glGetTexParameteriv },
+            { "glHint", (void *) ::glHint },
+            { "glIsEnabled", (void *) ::glIsEnabled },
+            { "glIsTexture", (void *) ::glIsTexture },
+            { "glLineWidth", (void *) ::glLineWidth },
+            { "glPixelStorei", (void *) ::glPixelStorei },
+            { "glPolygonOffset", (void *) ::glPolygonOffset },
+            { "glReadPixels", (void *) ::glReadPixels },
+            { "glScissor", (void *) ::glScissor },
+            { "glStencilFunc", (void *) ::glStencilFunc },
+            { "glStencilMask", (void *) ::glStencilMask },
+            { "glStencilOp", (void *) ::glStencilOp },
+            { "glTexImage2D", (void *) ::glTexImage2D },
+            { "glTexParameterf", (void *) ::glTexParameterf },
+            { "glTexParameterfv", (void *) ::glTexParameterfv },
+            { "glTexParameteri", (void *) ::glTexParameteri },
+            { "glTexParameteriv", (void *) ::glTexParameteriv },
+            { "glTexSubImage2D", (void *) ::glTexSubImage2D },
+            { "glViewport", (void *) ::glViewport },
 
-        { "glActiveTexture", (void *) QWindowsEGLStaticContext::libGLESv2.glActiveTexture },
-        { "glAttachShader", (void *) QWindowsEGLStaticContext::libGLESv2.glAttachShader },
-        { "glBindAttribLocation", (void *) QWindowsEGLStaticContext::libGLESv2.glBindAttribLocation },
-        { "glBindBuffer", (void *) QWindowsEGLStaticContext::libGLESv2.glBindBuffer },
-        { "glBindFramebuffer", (void *) QWindowsEGLStaticContext::libGLESv2.glBindFramebuffer },
-        { "glBindRenderbuffer", (void *) QWindowsEGLStaticContext::libGLESv2.glBindRenderbuffer },
-        { "glBlendColor", (void *) QWindowsEGLStaticContext::libGLESv2.glBlendColor },
-        { "glBlendEquation", (void *) QWindowsEGLStaticContext::libGLESv2.glBlendEquation },
-        { "glBlendEquationSeparate", (void *) QWindowsEGLStaticContext::libGLESv2.glBlendEquationSeparate },
-        { "glBlendFuncSeparate", (void *) QWindowsEGLStaticContext::libGLESv2.glBlendFuncSeparate },
-        { "glBufferData", (void *) QWindowsEGLStaticContext::libGLESv2.glBufferData },
-        { "glBufferSubData", (void *) QWindowsEGLStaticContext::libGLESv2.glBufferSubData },
-        { "glCheckFramebufferStatus", (void *) QWindowsEGLStaticContext::libGLESv2.glCheckFramebufferStatus },
-        { "glCompileShader", (void *) QWindowsEGLStaticContext::libGLESv2.glCompileShader },
-        { "glCompressedTexImage2D", (void *) QWindowsEGLStaticContext::libGLESv2.glCompressedTexImage2D },
-        { "glCompressedTexSubImage2D", (void *) QWindowsEGLStaticContext::libGLESv2.glCompressedTexSubImage2D },
-        { "glCreateProgram", (void *) QWindowsEGLStaticContext::libGLESv2.glCreateProgram },
-        { "glCreateShader", (void *) QWindowsEGLStaticContext::libGLESv2.glCreateShader },
-        { "glDeleteBuffers", (void *) QWindowsEGLStaticContext::libGLESv2.glDeleteBuffers },
-        { "glDeleteFramebuffers", (void *) QWindowsEGLStaticContext::libGLESv2.glDeleteFramebuffers },
-        { "glDeleteProgram", (void *) QWindowsEGLStaticContext::libGLESv2.glDeleteProgram },
-        { "glDeleteRenderbuffers", (void *) QWindowsEGLStaticContext::libGLESv2.glDeleteRenderbuffers },
-        { "glDeleteShader", (void *) QWindowsEGLStaticContext::libGLESv2.glDeleteShader },
-        { "glDetachShader", (void *) QWindowsEGLStaticContext::libGLESv2.glDetachShader },
-        { "glDisableVertexAttribArray", (void *) QWindowsEGLStaticContext::libGLESv2.glDisableVertexAttribArray },
-        { "glEnableVertexAttribArray", (void *) QWindowsEGLStaticContext::libGLESv2.glEnableVertexAttribArray },
-        { "glFramebufferRenderbuffer", (void *) QWindowsEGLStaticContext::libGLESv2.glFramebufferRenderbuffer },
-        { "glFramebufferTexture2D", (void *) QWindowsEGLStaticContext::libGLESv2.glFramebufferTexture2D },
-        { "glGenBuffers", (void *) QWindowsEGLStaticContext::libGLESv2.glGenBuffers },
-        { "glGenerateMipmap", (void *) QWindowsEGLStaticContext::libGLESv2.glGenerateMipmap },
-        { "glGenFramebuffers", (void *) QWindowsEGLStaticContext::libGLESv2.glGenFramebuffers },
-        { "glGenRenderbuffers", (void *) QWindowsEGLStaticContext::libGLESv2.glGenRenderbuffers },
-        { "glGetActiveAttrib", (void *) QWindowsEGLStaticContext::libGLESv2.glGetActiveAttrib },
-        { "glGetActiveUniform", (void *) QWindowsEGLStaticContext::libGLESv2.glGetActiveUniform },
-        { "glGetAttachedShaders", (void *) QWindowsEGLStaticContext::libGLESv2.glGetAttachedShaders },
-        { "glGetAttribLocation", (void *) QWindowsEGLStaticContext::libGLESv2.glGetAttribLocation },
-        { "glGetBufferParameteriv", (void *) QWindowsEGLStaticContext::libGLESv2.glGetBufferParameteriv },
-        { "glGetFramebufferAttachmentParameteriv", (void *) QWindowsEGLStaticContext::libGLESv2.glGetFramebufferAttachmentParameteriv },
-        { "glGetProgramiv", (void *) QWindowsEGLStaticContext::libGLESv2.glGetProgramiv },
-        { "glGetProgramInfoLog", (void *) QWindowsEGLStaticContext::libGLESv2.glGetProgramInfoLog },
-        { "glGetRenderbufferParameteriv", (void *) QWindowsEGLStaticContext::libGLESv2.glGetRenderbufferParameteriv },
-        { "glGetShaderiv", (void *) QWindowsEGLStaticContext::libGLESv2.glGetShaderiv },
-        { "glGetShaderInfoLog", (void *) QWindowsEGLStaticContext::libGLESv2.glGetShaderInfoLog },
-        { "glGetShaderPrecisionFormat", (void *) QWindowsEGLStaticContext::libGLESv2.glGetShaderPrecisionFormat },
-        { "glGetShaderSource", (void *) QWindowsEGLStaticContext::libGLESv2.glGetShaderSource },
-        { "glGetUniformfv", (void *) QWindowsEGLStaticContext::libGLESv2.glGetUniformfv },
-        { "glGetUniformiv", (void *) QWindowsEGLStaticContext::libGLESv2.glGetUniformiv },
-        { "glGetUniformLocation", (void *) QWindowsEGLStaticContext::libGLESv2.glGetUniformLocation },
-        { "glGetVertexAttribfv", (void *) QWindowsEGLStaticContext::libGLESv2.glGetVertexAttribfv },
-        { "glGetVertexAttribiv", (void *) QWindowsEGLStaticContext::libGLESv2.glGetVertexAttribiv },
-        { "glGetVertexAttribPointerv", (void *) QWindowsEGLStaticContext::libGLESv2.glGetVertexAttribPointerv },
-        { "glIsBuffer", (void *) QWindowsEGLStaticContext::libGLESv2.glIsBuffer },
-        { "glIsFramebuffer", (void *) QWindowsEGLStaticContext::libGLESv2.glIsFramebuffer },
-        { "glIsProgram", (void *) QWindowsEGLStaticContext::libGLESv2.glIsProgram },
-        { "glIsRenderbuffer", (void *) QWindowsEGLStaticContext::libGLESv2.glIsRenderbuffer },
-        { "glIsShader", (void *) QWindowsEGLStaticContext::libGLESv2.glIsShader },
-        { "glLinkProgram", (void *) QWindowsEGLStaticContext::libGLESv2.glLinkProgram },
-        { "glReleaseShaderCompiler", (void *) QWindowsEGLStaticContext::libGLESv2.glReleaseShaderCompiler },
-        { "glRenderbufferStorage", (void *) QWindowsEGLStaticContext::libGLESv2.glRenderbufferStorage },
-        { "glSampleCoverage", (void *) QWindowsEGLStaticContext::libGLESv2.glSampleCoverage },
-        { "glShaderBinary", (void *) QWindowsEGLStaticContext::libGLESv2.glShaderBinary },
-        { "glShaderSource", (void *) QWindowsEGLStaticContext::libGLESv2.glShaderSource },
-        { "glStencilFuncSeparate", (void *) QWindowsEGLStaticContext::libGLESv2.glStencilFuncSeparate },
-        { "glStencilMaskSeparate", (void *) QWindowsEGLStaticContext::libGLESv2.glStencilMaskSeparate },
-        { "glStencilOpSeparate", (void *) QWindowsEGLStaticContext::libGLESv2.glStencilOpSeparate },
-        { "glUniform1f", (void *) QWindowsEGLStaticContext::libGLESv2.glUniform1f },
-        { "glUniform1fv", (void *) QWindowsEGLStaticContext::libGLESv2.glUniform1fv },
-        { "glUniform1i", (void *) QWindowsEGLStaticContext::libGLESv2.glUniform1i },
-        { "glUniform1iv", (void *) QWindowsEGLStaticContext::libGLESv2.glUniform1iv },
-        { "glUniform2f", (void *) QWindowsEGLStaticContext::libGLESv2.glUniform2f },
-        { "glUniform2fv", (void *) QWindowsEGLStaticContext::libGLESv2.glUniform2fv },
-        { "glUniform2i", (void *) QWindowsEGLStaticContext::libGLESv2.glUniform2i },
-        { "glUniform2iv", (void *) QWindowsEGLStaticContext::libGLESv2.glUniform2iv },
-        { "glUniform3f", (void *) QWindowsEGLStaticContext::libGLESv2.glUniform3f },
-        { "glUniform3fv", (void *) QWindowsEGLStaticContext::libGLESv2.glUniform3fv },
-        { "glUniform3i", (void *) QWindowsEGLStaticContext::libGLESv2.glUniform3i },
-        { "glUniform3iv", (void *) QWindowsEGLStaticContext::libGLESv2.glUniform3iv },
-        { "glUniform4f", (void *) QWindowsEGLStaticContext::libGLESv2.glUniform4f },
-        { "glUniform4fv", (void *) QWindowsEGLStaticContext::libGLESv2.glUniform4fv },
-        { "glUniform4i", (void *) QWindowsEGLStaticContext::libGLESv2.glUniform4i },
-        { "glUniform4iv", (void *) QWindowsEGLStaticContext::libGLESv2.glUniform4iv },
-        { "glUniformMatrix2fv", (void *) QWindowsEGLStaticContext::libGLESv2.glUniformMatrix2fv },
-        { "glUniformMatrix3fv", (void *) QWindowsEGLStaticContext::libGLESv2.glUniformMatrix3fv },
-        { "glUniformMatrix4fv", (void *) QWindowsEGLStaticContext::libGLESv2.glUniformMatrix4fv },
-        { "glUseProgram", (void *) QWindowsEGLStaticContext::libGLESv2.glUseProgram },
-        { "glValidateProgram", (void *) QWindowsEGLStaticContext::libGLESv2.glValidateProgram },
-        { "glVertexAttrib1f", (void *) QWindowsEGLStaticContext::libGLESv2.glVertexAttrib1f },
-        { "glVertexAttrib1fv", (void *) QWindowsEGLStaticContext::libGLESv2.glVertexAttrib1fv },
-        { "glVertexAttrib2f", (void *) QWindowsEGLStaticContext::libGLESv2.glVertexAttrib2f },
-        { "glVertexAttrib2fv", (void *) QWindowsEGLStaticContext::libGLESv2.glVertexAttrib2fv },
-        { "glVertexAttrib3f", (void *) QWindowsEGLStaticContext::libGLESv2.glVertexAttrib3f },
-        { "glVertexAttrib3fv", (void *) QWindowsEGLStaticContext::libGLESv2.glVertexAttrib3fv },
-        { "glVertexAttrib4f", (void *) QWindowsEGLStaticContext::libGLESv2.glVertexAttrib4f },
-        { "glVertexAttrib4fv", (void *) QWindowsEGLStaticContext::libGLESv2.glVertexAttrib4fv },
-        { "glVertexAttribPointer", (void *) QWindowsEGLStaticContext::libGLESv2.glVertexAttribPointer },
+            { "glActiveTexture", (void *) ::glActiveTexture },
+            { "glAttachShader", (void *) ::glAttachShader },
+            { "glBindAttribLocation", (void *) ::glBindAttribLocation },
+            { "glBindBuffer", (void *) ::glBindBuffer },
+            { "glBindFramebuffer", (void *) ::glBindFramebuffer },
+            { "glBindRenderbuffer", (void *) ::glBindRenderbuffer },
+            { "glBlendColor", (void *) ::glBlendColor },
+            { "glBlendEquation", (void *) ::glBlendEquation },
+            { "glBlendEquationSeparate", (void *) ::glBlendEquationSeparate },
+            { "glBlendFuncSeparate", (void *) ::glBlendFuncSeparate },
+            { "glBufferData", (void *) ::glBufferData },
+            { "glBufferSubData", (void *) ::glBufferSubData },
+            { "glCheckFramebufferStatus", (void *) ::glCheckFramebufferStatus },
+            { "glCompileShader", (void *) ::glCompileShader },
+            { "glCompressedTexImage2D", (void *) ::glCompressedTexImage2D },
+            { "glCompressedTexSubImage2D", (void *) ::glCompressedTexSubImage2D },
+            { "glCreateProgram", (void *) ::glCreateProgram },
+            { "glCreateShader", (void *) ::glCreateShader },
+            { "glDeleteBuffers", (void *) ::glDeleteBuffers },
+            { "glDeleteFramebuffers", (void *) ::glDeleteFramebuffers },
+            { "glDeleteProgram", (void *) ::glDeleteProgram },
+            { "glDeleteRenderbuffers", (void *) ::glDeleteRenderbuffers },
+            { "glDeleteShader", (void *) ::glDeleteShader },
+            { "glDetachShader", (void *) ::glDetachShader },
+            { "glDisableVertexAttribArray", (void *) ::glDisableVertexAttribArray },
+            { "glEnableVertexAttribArray", (void *) ::glEnableVertexAttribArray },
+            { "glFramebufferRenderbuffer", (void *) ::glFramebufferRenderbuffer },
+            { "glFramebufferTexture2D", (void *) ::glFramebufferTexture2D },
+            { "glGenBuffers", (void *) ::glGenBuffers },
+            { "glGenerateMipmap", (void *) ::glGenerateMipmap },
+            { "glGenFramebuffers", (void *) ::glGenFramebuffers },
+            { "glGenRenderbuffers", (void *) ::glGenRenderbuffers },
+            { "glGetActiveAttrib", (void *) ::glGetActiveAttrib },
+            { "glGetActiveUniform", (void *) ::glGetActiveUniform },
+            { "glGetAttachedShaders", (void *) ::glGetAttachedShaders },
+            { "glGetAttribLocation", (void *) ::glGetAttribLocation },
+            { "glGetBufferParameteriv", (void *) ::glGetBufferParameteriv },
+            { "glGetFramebufferAttachmentParameteriv", (void *) ::glGetFramebufferAttachmentParameteriv },
+            { "glGetProgramiv", (void *) ::glGetProgramiv },
+            { "glGetProgramInfoLog", (void *) ::glGetProgramInfoLog },
+            { "glGetRenderbufferParameteriv", (void *) ::glGetRenderbufferParameteriv },
+            { "glGetShaderiv", (void *) ::glGetShaderiv },
+            { "glGetShaderInfoLog", (void *) ::glGetShaderInfoLog },
+            { "glGetShaderPrecisionFormat", (void *) ::glGetShaderPrecisionFormat },
+            { "glGetShaderSource", (void *) ::glGetShaderSource },
+            { "glGetUniformfv", (void *) ::glGetUniformfv },
+            { "glGetUniformiv", (void *) ::glGetUniformiv },
+            { "glGetUniformLocation", (void *) ::glGetUniformLocation },
+            { "glGetVertexAttribfv", (void *) ::glGetVertexAttribfv },
+            { "glGetVertexAttribiv", (void *) ::glGetVertexAttribiv },
+            { "glGetVertexAttribPointerv", (void *) ::glGetVertexAttribPointerv },
+            { "glIsBuffer", (void *) ::glIsBuffer },
+            { "glIsFramebuffer", (void *) ::glIsFramebuffer },
+            { "glIsProgram", (void *) ::glIsProgram },
+            { "glIsRenderbuffer", (void *) ::glIsRenderbuffer },
+            { "glIsShader", (void *) ::glIsShader },
+            { "glLinkProgram", (void *) ::glLinkProgram },
+            { "glReleaseShaderCompiler", (void *) ::glReleaseShaderCompiler },
+            { "glRenderbufferStorage", (void *) ::glRenderbufferStorage },
+            { "glSampleCoverage", (void *) ::glSampleCoverage },
+            { "glShaderBinary", (void *) ::glShaderBinary },
+            { "glShaderSource", (void *) ::glShaderSource },
+            { "glStencilFuncSeparate", (void *) ::glStencilFuncSeparate },
+            { "glStencilMaskSeparate", (void *) ::glStencilMaskSeparate },
+            { "glStencilOpSeparate", (void *) ::glStencilOpSeparate },
+            { "glUniform1f", (void *) ::glUniform1f },
+            { "glUniform1fv", (void *) ::glUniform1fv },
+            { "glUniform1i", (void *) ::glUniform1i },
+            { "glUniform1iv", (void *) ::glUniform1iv },
+            { "glUniform2f", (void *) ::glUniform2f },
+            { "glUniform2fv", (void *) ::glUniform2fv },
+            { "glUniform2i", (void *) ::glUniform2i },
+            { "glUniform2iv", (void *) ::glUniform2iv },
+            { "glUniform3f", (void *) ::glUniform3f },
+            { "glUniform3fv", (void *) ::glUniform3fv },
+            { "glUniform3i", (void *) ::glUniform3i },
+            { "glUniform3iv", (void *) ::glUniform3iv },
+            { "glUniform4f", (void *) ::glUniform4f },
+            { "glUniform4fv", (void *) ::glUniform4fv },
+            { "glUniform4i", (void *) ::glUniform4i },
+            { "glUniform4iv", (void *) ::glUniform4iv },
+            { "glUniformMatrix2fv", (void *) ::glUniformMatrix2fv },
+            { "glUniformMatrix3fv", (void *) ::glUniformMatrix3fv },
+            { "glUniformMatrix4fv", (void *) ::glUniformMatrix4fv },
+            { "glUseProgram", (void *) ::glUseProgram },
+            { "glValidateProgram", (void *) ::glValidateProgram },
+            { "glVertexAttrib1f", (void *) ::glVertexAttrib1f },
+            { "glVertexAttrib1fv", (void *) ::glVertexAttrib1fv },
+            { "glVertexAttrib2f", (void *) ::glVertexAttrib2f },
+            { "glVertexAttrib2fv", (void *) ::glVertexAttrib2fv },
+            { "glVertexAttrib3f", (void *) ::glVertexAttrib3f },
+            { "glVertexAttrib3fv", (void *) ::glVertexAttrib3fv },
+            { "glVertexAttrib4f", (void *) ::glVertexAttrib4f },
+            { "glVertexAttrib4fv", (void *) ::glVertexAttrib4fv },
+            { "glVertexAttribPointer", (void *) ::glVertexAttribPointer },
 
-        { "glClearDepthf", (void *) QWindowsEGLStaticContext::libGLESv2.glClearDepthf },
-        { "glDepthRangef", (void *) QWindowsEGLStaticContext::libGLESv2.glDepthRangef }
-    };
-    for (size_t i = 0; i < sizeof(standardFuncs) / sizeof(StdFunc); ++i)
-        if (procName == standardFuncs[i].name)
-            return reinterpret_cast<QFunctionPointer>(standardFuncs[i].func);
+            { "glClearDepthf", (void *) ::glClearDepthf },
+            { "glDepthRangef", (void *) ::glDepthRangef }
+        };
+        for (size_t i = 0; i < sizeof(standardFuncs) / sizeof(StdFunc); ++i)
+            if (!qstrcmp(procName, standardFuncs[i].name))
+                return reinterpret_cast<QFunctionPointer>(standardFuncs[i].func);
+#else
+            procAddress = reinterpret_cast<QFunctionPointer>(QWindowsEGLStaticContext::libGLESv2.resolve(procName));
+#endif
+}
 
-    QWindowsEGLStaticContext::libEGL.eglBindAPI(m_api);
-    QFunctionPointer procAddress = reinterpret_cast<QFunctionPointer>(QWindowsEGLStaticContext::libEGL.eglGetProcAddress(procName.constData()));
     if (QWindowsContext::verbose > 1)
         qCDebug(lcQpaGl) << __FUNCTION__ <<  procName << QWindowsEGLStaticContext::libEGL.eglGetCurrentContext() << "returns" << procAddress;
-    if (!procAddress && QWindowsContext::verbose)
-        qWarning("%s: Unable to resolve '%s'", __FUNCTION__, procName.constData());
+
     return procAddress;
 }
 
diff --git a/src/plugins/platforms/windows/qwindowseglcontext.h b/src/plugins/platforms/windows/qwindowseglcontext.h
index ccc2cdcad1e..c7f7cee3c24 100644
--- a/src/plugins/platforms/windows/qwindowseglcontext.h
+++ b/src/plugins/platforms/windows/qwindowseglcontext.h
@@ -98,157 +98,11 @@ struct QWindowsLibGLESv2
     void *moduleHandle() const { return Q_NULLPTR; }
 #endif
 
-    // GL1+GLES2 common
-    void (APIENTRY * glBindTexture)(GLenum target, GLuint texture);
-    void (APIENTRY * glBlendFunc)(GLenum sfactor, GLenum dfactor);
-    void (APIENTRY * glClear)(GLbitfield mask);
-    void (APIENTRY * glClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-    void (APIENTRY * glClearStencil)(GLint s);
-    void (APIENTRY * glColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void (APIENTRY * glCopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void (APIENTRY * glCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void (APIENTRY * glCullFace)(GLenum mode);
-    void (APIENTRY * glDeleteTextures)(GLsizei n, const GLuint* textures);
-    void (APIENTRY * glDepthFunc)(GLenum func);
-    void (APIENTRY * glDepthMask)(GLboolean flag);
-    void (APIENTRY * glDisable)(GLenum cap);
-    void (APIENTRY * glDrawArrays)(GLenum mode, GLint first, GLsizei count);
-    void (APIENTRY * glDrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices);
-    void (APIENTRY * glEnable)(GLenum cap);
-    void (APIENTRY * glFinish)();
-    void (APIENTRY * glFlush)();
-    void (APIENTRY * glFrontFace)(GLenum mode);
-    void (APIENTRY * glGenTextures)(GLsizei n, GLuint* textures);
-    void (APIENTRY * glGetBooleanv)(GLenum pname, GLboolean* params);
-    GLenum (APIENTRY * glGetError)();
-    void (APIENTRY * glGetFloatv)(GLenum pname, GLfloat* params);
-    void (APIENTRY * glGetIntegerv)(GLenum pname, GLint* params);
     const GLubyte * (APIENTRY * glGetString)(GLenum name);
-    void (APIENTRY * glGetTexParameterfv)(GLenum target, GLenum pname, GLfloat* params);
-    void (APIENTRY * glGetTexParameteriv)(GLenum target, GLenum pname, GLint* params);
-    void (APIENTRY * glHint)(GLenum target, GLenum mode);
-    GLboolean (APIENTRY * glIsEnabled)(GLenum cap);
-    GLboolean (APIENTRY * glIsTexture)(GLuint texture);
-    void (APIENTRY * glLineWidth)(GLfloat width);
-    void (APIENTRY * glPixelStorei)(GLenum pname, GLint param);
-    void (APIENTRY * glPolygonOffset)(GLfloat factor, GLfloat units);
-    void (APIENTRY * glReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);
-    void (APIENTRY * glScissor)(GLint x, GLint y, GLsizei width, GLsizei height);
-    void (APIENTRY * glStencilFunc)(GLenum func, GLint ref, GLuint mask);
-    void (APIENTRY * glStencilMask)(GLuint mask);
-    void (APIENTRY * glStencilOp)(GLenum fail, GLenum zfail, GLenum zpass);
-    void (APIENTRY * glTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
-    void (APIENTRY * glTexParameterf)(GLenum target, GLenum pname, GLfloat param);
-    void (APIENTRY * glTexParameterfv)(GLenum target, GLenum pname, const GLfloat* params);
-    void (APIENTRY * glTexParameteri)(GLenum target, GLenum pname, GLint param);
-    void (APIENTRY * glTexParameteriv)(GLenum target, GLenum pname, const GLint* params);
-    void (APIENTRY * glTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels);
-    void (APIENTRY * glViewport)(GLint x, GLint y, GLsizei width, GLsizei height);
 
-    // GLES2
-    void (APIENTRY * glActiveTexture)(GLenum texture);
-    void (APIENTRY * glAttachShader)(GLuint program, GLuint shader);
-    void (APIENTRY * glBindAttribLocation)(GLuint program, GLuint index, const char* name);
-    void (APIENTRY * glBindBuffer)(GLenum target, GLuint buffer);
-    void (APIENTRY * glBindFramebuffer)(GLenum target, GLuint framebuffer);
-    void (APIENTRY * glBindRenderbuffer)(GLenum target, GLuint renderbuffer);
-    void (APIENTRY * glBlendColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-    void (APIENTRY * glBlendEquation)(GLenum mode);
-    void (APIENTRY * glBlendEquationSeparate)(GLenum modeRGB, GLenum modeAlpha);
-    void (APIENTRY * glBlendFuncSeparate)(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha);
-    void (APIENTRY * glBufferData)(GLenum target, qopengl_GLsizeiptr size, const void* data, GLenum usage);
-    void (APIENTRY * glBufferSubData)(GLenum target, qopengl_GLintptr offset, qopengl_GLsizeiptr size, const void* data);
-    GLenum (APIENTRY * glCheckFramebufferStatus)(GLenum target);
-    void (APIENTRY * glCompileShader)(GLuint shader);
-    void (APIENTRY * glCompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void* data);
-    void (APIENTRY * glCompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void* data);
-    GLuint (APIENTRY * glCreateProgram)();
-    GLuint (APIENTRY * glCreateShader)(GLenum type);
-    void (APIENTRY * glDeleteBuffers)(GLsizei n, const GLuint* buffers);
-    void (APIENTRY * glDeleteFramebuffers)(GLsizei n, const GLuint* framebuffers);
-    void (APIENTRY * glDeleteProgram)(GLuint program);
-    void (APIENTRY * glDeleteRenderbuffers)(GLsizei n, const GLuint* renderbuffers);
-    void (APIENTRY * glDeleteShader)(GLuint shader);
-    void (APIENTRY * glDetachShader)(GLuint program, GLuint shader);
-    void (APIENTRY * glDisableVertexAttribArray)(GLuint index);
-    void (APIENTRY * glEnableVertexAttribArray)(GLuint index);
-    void (APIENTRY * glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer);
-    void (APIENTRY * glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level);
-    void (APIENTRY * glGenBuffers)(GLsizei n, GLuint* buffers);
-    void (APIENTRY * glGenerateMipmap)(GLenum target);
-    void (APIENTRY * glGenFramebuffers)(GLsizei n, GLuint* framebuffers);
-    void (APIENTRY * glGenRenderbuffers)(GLsizei n, GLuint* renderbuffers);
-    void (APIENTRY * glGetActiveAttrib)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
-    void (APIENTRY * glGetActiveUniform)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, char* name);
-    void (APIENTRY * glGetAttachedShaders)(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders);
-    GLint (APIENTRY * glGetAttribLocation)(GLuint program, const char* name);
-    void (APIENTRY * glGetBufferParameteriv)(GLenum target, GLenum pname, GLint* params);
-    void (APIENTRY * glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint* params);
-    void (APIENTRY * glGetProgramiv)(GLuint program, GLenum pname, GLint* params);
-    void (APIENTRY * glGetProgramInfoLog)(GLuint program, GLsizei bufsize, GLsizei* length, char* infolog);
-    void (APIENTRY * glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint* params);
-    void (APIENTRY * glGetShaderiv)(GLuint shader, GLenum pname, GLint* params);
-    void (APIENTRY * glGetShaderInfoLog)(GLuint shader, GLsizei bufsize, GLsizei* length, char* infolog);
-    void (APIENTRY * glGetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision);
-    void (APIENTRY * glGetShaderSource)(GLuint shader, GLsizei bufsize, GLsizei* length, char* source);
-    void (APIENTRY * glGetUniformfv)(GLuint program, GLint location, GLfloat* params);
-    void (APIENTRY * glGetUniformiv)(GLuint program, GLint location, GLint* params);
-    GLint (APIENTRY * glGetUniformLocation)(GLuint program, const char* name);
-    void (APIENTRY * glGetVertexAttribfv)(GLuint index, GLenum pname, GLfloat* params);
-    void (APIENTRY * glGetVertexAttribiv)(GLuint index, GLenum pname, GLint* params);
-    void (APIENTRY * glGetVertexAttribPointerv)(GLuint index, GLenum pname, void** pointer);
-    GLboolean (APIENTRY * glIsBuffer)(GLuint buffer);
-    GLboolean (APIENTRY * glIsFramebuffer)(GLuint framebuffer);
-    GLboolean (APIENTRY * glIsProgram)(GLuint program);
-    GLboolean (APIENTRY * glIsRenderbuffer)(GLuint renderbuffer);
-    GLboolean (APIENTRY * glIsShader)(GLuint shader);
-    void (APIENTRY * glLinkProgram)(GLuint program);
-    void (APIENTRY * glReleaseShaderCompiler)();
-    void (APIENTRY * glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height);
-    void (APIENTRY * glSampleCoverage)(GLclampf value, GLboolean invert);
-    void (APIENTRY * glShaderBinary)(GLint n, const GLuint* shaders, GLenum binaryformat, const void* binary, GLint length);
-    void (APIENTRY * glShaderSource)(GLuint shader, GLsizei count, const char** string, const GLint* length);
-    void (APIENTRY * glStencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask);
-    void (APIENTRY * glStencilMaskSeparate)(GLenum face, GLuint mask);
-    void (APIENTRY * glStencilOpSeparate)(GLenum face, GLenum fail, GLenum zfail, GLenum zpass);
-    void (APIENTRY * glUniform1f)(GLint location, GLfloat x);
-    void (APIENTRY * glUniform1fv)(GLint location, GLsizei count, const GLfloat* v);
-    void (APIENTRY * glUniform1i)(GLint location, GLint x);
-    void (APIENTRY * glUniform1iv)(GLint location, GLsizei count, const GLint* v);
-    void (APIENTRY * glUniform2f)(GLint location, GLfloat x, GLfloat y);
-    void (APIENTRY * glUniform2fv)(GLint location, GLsizei count, const GLfloat* v);
-    void (APIENTRY * glUniform2i)(GLint location, GLint x, GLint y);
-    void (APIENTRY * glUniform2iv)(GLint location, GLsizei count, const GLint* v);
-    void (APIENTRY * glUniform3f)(GLint location, GLfloat x, GLfloat y, GLfloat z);
-    void (APIENTRY * glUniform3fv)(GLint location, GLsizei count, const GLfloat* v);
-    void (APIENTRY * glUniform3i)(GLint location, GLint x, GLint y, GLint z);
-    void (APIENTRY * glUniform3iv)(GLint location, GLsizei count, const GLint* v);
-    void (APIENTRY * glUniform4f)(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void (APIENTRY * glUniform4fv)(GLint location, GLsizei count, const GLfloat* v);
-    void (APIENTRY * glUniform4i)(GLint location, GLint x, GLint y, GLint z, GLint w);
-    void (APIENTRY * glUniform4iv)(GLint location, GLsizei count, const GLint* v);
-    void (APIENTRY * glUniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-    void (APIENTRY * glUniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-    void (APIENTRY * glUniformMatrix4fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value);
-    void (APIENTRY * glUseProgram)(GLuint program);
-    void (APIENTRY * glValidateProgram)(GLuint program);
-    void (APIENTRY * glVertexAttrib1f)(GLuint indx, GLfloat x);
-    void (APIENTRY * glVertexAttrib1fv)(GLuint indx, const GLfloat* values);
-    void (APIENTRY * glVertexAttrib2f)(GLuint indx, GLfloat x, GLfloat y);
-    void (APIENTRY * glVertexAttrib2fv)(GLuint indx, const GLfloat* values);
-    void (APIENTRY * glVertexAttrib3f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z);
-    void (APIENTRY * glVertexAttrib3fv)(GLuint indx, const GLfloat* values);
-    void (APIENTRY * glVertexAttrib4f)(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
-    void (APIENTRY * glVertexAttrib4fv)(GLuint indx, const GLfloat* values);
-    void (APIENTRY * glVertexAttribPointer)(GLuint indx, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* ptr);
-
-    // ES only
-    void (APIENTRY * glClearDepthf)(GLclampf depth);
-    void (APIENTRY * glDepthRangef)(GLclampf nearVal, GLclampf farVal);
-
-private:
 #if !defined(QT_STATIC) || defined(QT_OPENGL_DYNAMIC)
     void *resolve(const char *name);
+private:
     HMODULE m_lib;
 #endif
 };
@@ -292,7 +146,7 @@ public:
     bool makeCurrent(QPlatformSurface *surface) Q_DECL_OVERRIDE;
     void doneCurrent() Q_DECL_OVERRIDE;
     void swapBuffers(QPlatformSurface *surface) Q_DECL_OVERRIDE;
-    QFunctionPointer getProcAddress(const QByteArray &procName) Q_DECL_OVERRIDE;
+    QFunctionPointer getProcAddress(const char *procName) Q_DECL_OVERRIDE;
 
     QSurfaceFormat format() const Q_DECL_OVERRIDE { return m_format; }
     bool isSharing() const Q_DECL_OVERRIDE { return m_shareContext != EGL_NO_CONTEXT; }
diff --git a/src/plugins/platforms/windows/qwindowsfontdatabase.cpp b/src/plugins/platforms/windows/qwindowsfontdatabase.cpp
index 743408949d2..966be8c9918 100644
--- a/src/plugins/platforms/windows/qwindowsfontdatabase.cpp
+++ b/src/plugins/platforms/windows/qwindowsfontdatabase.cpp
@@ -1769,28 +1769,35 @@ QFontEngine *QWindowsFontDatabase::createEngine(const QFontDef &request,
             lf.lfFaceName[nameSubstituteLength] = 0;
         }
 
-        IDWriteFont *directWriteFont = 0;
-        HRESULT hr = data->directWriteGdiInterop->CreateFontFromLOGFONT(&lf, &directWriteFont);
-        if (FAILED(hr)) {
-            const QString errorString = qt_error_string(int(GetLastError()));
-            qWarning().noquote().nospace() << "DirectWrite: CreateFontFromLOGFONT() failed ("
-                << errorString << ") for " << request << ' ' << lf << " dpi=" << dpi;
+        HFONT hfont = CreateFontIndirect(&lf);
+        if (!hfont) {
+            qErrnoWarning("%s: CreateFontIndirect failed", __FUNCTION__);
         } else {
+            HGDIOBJ oldFont = SelectObject(data->hdc, hfont);
+
             IDWriteFontFace *directWriteFontFace = NULL;
-            hr = directWriteFont->CreateFontFace(&directWriteFontFace);
+            HRESULT hr = data->directWriteGdiInterop->CreateFontFaceFromHdc(data->hdc, &directWriteFontFace);
             if (FAILED(hr)) {
-                const QString errorString = qt_error_string(int(GetLastError()));
-                qWarning().noquote() << "DirectWrite: CreateFontFace() failed ("
+                const QString errorString = qt_error_string(int(hr));
+                qWarning().noquote().nospace() << "DirectWrite: CreateFontFaceFromHDC() failed ("
                     << errorString << ") for " << request << ' ' << lf << " dpi=" << dpi;
             } else {
                 QWindowsFontEngineDirectWrite *fedw = new QWindowsFontEngineDirectWrite(directWriteFontFace,
                                                                                         request.pixelSize,
                                                                                         data);
-                fedw->initFontInfo(request, dpi, directWriteFont);
+
+                wchar_t n[64];
+                GetTextFace(data->hdc, 64, n);
+
+                QFontDef fontDef = request;
+                fontDef.family = QString::fromWCharArray(n);
+
+                fedw->initFontInfo(fontDef, dpi);
                 fe = fedw;
             }
 
-            directWriteFont->Release();
+            SelectObject(data->hdc, oldFont);
+            DeleteObject(hfont);
         }
     }
 #endif // QT_NO_DIRECTWRITE
diff --git a/src/plugins/platforms/windows/qwindowsfontengine.cpp b/src/plugins/platforms/windows/qwindowsfontengine.cpp
index c78412c8ecc..a3e3870d90d 100644
--- a/src/plugins/platforms/windows/qwindowsfontengine.cpp
+++ b/src/plugins/platforms/windows/qwindowsfontengine.cpp
@@ -37,11 +37,6 @@
 **
 ****************************************************************************/
 
-#if _WIN32_WINNT < 0x0500
-#undef _WIN32_WINNT
-#define _WIN32_WINNT 0x0500
-#endif
-
 #include "qwindowsintegration.h"
 #include "qwindowsfontengine.h"
 #include "qwindowsnativeimage.h"
@@ -85,11 +80,8 @@ QT_BEGIN_NAMESPACE
 #define TT_PRIM_CSPLINE 3
 #endif
 
-#ifdef MAKE_TAG
-#undef MAKE_TAG
-#endif
 // GetFontData expects the tags in little endian ;(
-#define MAKE_TAG(ch1, ch2, ch3, ch4) (\
+#define MAKE_LITTLE_ENDIAN_TAG(ch1, ch2, ch3, ch4) (\
     (((quint32)(ch4)) << 24) | \
     (((quint32)(ch3)) << 16) | \
     (((quint32)(ch2)) << 8) | \
@@ -142,28 +134,28 @@ bool QWindowsFontEngine::hasCFFTable() const
 {
     HDC hdc = m_fontEngineData->hdc;
     SelectObject(hdc, hfont);
-    return GetFontData(hdc, MAKE_TAG('C', 'F', 'F', ' '), 0, 0, 0) != GDI_ERROR;
+    return GetFontData(hdc, MAKE_LITTLE_ENDIAN_TAG('C', 'F', 'F', ' '), 0, 0, 0) != GDI_ERROR;
 }
 
 bool QWindowsFontEngine::hasCMapTable() const
 {
     HDC hdc = m_fontEngineData->hdc;
     SelectObject(hdc, hfont);
-    return GetFontData(hdc, MAKE_TAG('c', 'm', 'a', 'p'), 0, 0, 0) != GDI_ERROR;
+    return GetFontData(hdc, MAKE_LITTLE_ENDIAN_TAG('c', 'm', 'a', 'p'), 0, 0, 0) != GDI_ERROR;
 }
 
 bool QWindowsFontEngine::hasGlyfTable() const
 {
     HDC hdc = m_fontEngineData->hdc;
     SelectObject(hdc, hfont);
-    return GetFontData(hdc, MAKE_TAG('g', 'l', 'y', 'f'), 0, 0, 0) != GDI_ERROR;
+    return GetFontData(hdc, MAKE_LITTLE_ENDIAN_TAG('g', 'l', 'y', 'f'), 0, 0, 0) != GDI_ERROR;
 }
 
 bool QWindowsFontEngine::hasEbdtTable() const
 {
     HDC hdc = m_fontEngineData->hdc;
     SelectObject(hdc, hfont);
-    return GetFontData(hdc, MAKE_TAG('E', 'B', 'D', 'T'), 0, 0, 0) != GDI_ERROR;
+    return GetFontData(hdc, MAKE_LITTLE_ENDIAN_TAG('E', 'B', 'D', 'T'), 0, 0, 0) != GDI_ERROR;
 }
 
 static inline QString stringFromOutLineTextMetric(const OUTLINETEXTMETRIC *otm, PSTR offset)
@@ -182,7 +174,7 @@ void QWindowsFontEngine::getCMap()
     SelectObject(hdc, hfont);
     bool symb = false;
     if (ttf) {
-        cmapTable = getSfntTable(qbswap<quint32>(MAKE_TAG('c', 'm', 'a', 'p')));
+        cmapTable = getSfntTable(MAKE_TAG('c', 'm', 'a', 'p'));
         cmap = QFontEngine::getCMap(reinterpret_cast<const uchar *>(cmapTable.constData()),
                        cmapTable.size(), &symb, &cmapSize);
     }
@@ -956,7 +948,7 @@ int QWindowsFontEngine::synthesized() const
     if(synthesized_flags == -1) {
         synthesized_flags = 0;
         if(ttf) {
-            const DWORD HEAD = MAKE_TAG('h', 'e', 'a', 'd');
+            const DWORD HEAD = MAKE_LITTLE_ENDIAN_TAG('h', 'e', 'a', 'd');
             HDC hdc = m_fontEngineData->hdc;
             SelectObject(hdc, hfont);
             uchar data[4];
diff --git a/src/plugins/platforms/windows/qwindowsfontenginedirectwrite.cpp b/src/plugins/platforms/windows/qwindowsfontenginedirectwrite.cpp
index 2831962ef4e..eeb9e5eb6e3 100644
--- a/src/plugins/platforms/windows/qwindowsfontenginedirectwrite.cpp
+++ b/src/plugins/platforms/windows/qwindowsfontenginedirectwrite.cpp
@@ -39,15 +39,6 @@
 
 #ifndef QT_NO_DIRECTWRITE
 
-#if WINVER < 0x0600
-#  undef WINVER
-#  define WINVER 0x0600
-#endif
-#if _WIN32_WINNT < 0x0600
-#undef _WIN32_WINNT
-#define _WIN32_WINNT 0x0600
-#endif
-
 #include "qwindowsfontenginedirectwrite.h"
 #include "qwindowsfontdatabase.h"
 #include "qwindowscontext.h"
@@ -654,71 +645,11 @@ QFontEngine *QWindowsFontEngineDirectWrite::cloneWithSize(qreal pixelSize) const
     return fontEngine;
 }
 
-// Dynamically resolve GetUserDefaultLocaleName, which is available from Windows
-// Vista onwards. ### fixme 5.7: Consider reverting to direct linking.
-typedef int (WINAPI *GetUserDefaultLocaleNamePtr)(LPWSTR, int);
-
-static inline GetUserDefaultLocaleNamePtr resolveGetUserDefaultLocaleName()
-{
-    QSystemLibrary library(QStringLiteral("kernel32"));
-    return (GetUserDefaultLocaleNamePtr)library.resolve("GetUserDefaultLocaleName");
-}
-
 void QWindowsFontEngineDirectWrite::initFontInfo(const QFontDef &request,
-                                                 int dpi, IDWriteFont *font)
+                                                 int dpi)
 {
     fontDef = request;
 
-    IDWriteFontFamily *fontFamily = NULL;
-    HRESULT hr = font->GetFontFamily(&fontFamily);
-
-    IDWriteLocalizedStrings *familyNames = NULL;
-    if (SUCCEEDED(hr))
-        hr = fontFamily->GetFamilyNames(&familyNames);
-
-    UINT32 index = 0;
-
-    if (SUCCEEDED(hr)) {
-        BOOL exists = false;
-
-        wchar_t localeName[LOCALE_NAME_MAX_LENGTH];
-        static const GetUserDefaultLocaleNamePtr getUserDefaultLocaleName = resolveGetUserDefaultLocaleName();
-        const int defaultLocaleSuccess = getUserDefaultLocaleName
-            ? getUserDefaultLocaleName(localeName, LOCALE_NAME_MAX_LENGTH) : 0;
-        if (defaultLocaleSuccess)
-            hr = familyNames->FindLocaleName(localeName, &index, &exists);
-
-        if (SUCCEEDED(hr) && !exists)
-            hr = familyNames->FindLocaleName(L"en-us", &index, &exists);
-
-        if (!exists)
-            index = 0;
-    }
-
-    // Get the family name.
-    if (SUCCEEDED(hr)) {
-        UINT32 length = 0;
-
-        hr = familyNames->GetStringLength(index, &length);
-
-        if (SUCCEEDED(hr)) {
-            QVarLengthArray<wchar_t, 128> name(length+1);
-
-            hr = familyNames->GetString(index, name.data(), name.size());
-
-            if (SUCCEEDED(hr))
-                fontDef.family = QString::fromWCharArray(name.constData());
-        }
-    }
-
-    if (familyNames != NULL)
-        familyNames->Release();
-    if (fontFamily)
-        fontFamily->Release();
-
-    if (FAILED(hr))
-        qErrnoWarning(hr, "initFontInfo: Failed to get family name");
-
     if (fontDef.pointSize < 0)
         fontDef.pointSize = fontDef.pixelSize * 72. / dpi;
     else if (fontDef.pixelSize == -1)
diff --git a/src/plugins/platforms/windows/qwindowsfontenginedirectwrite.h b/src/plugins/platforms/windows/qwindowsfontenginedirectwrite.h
index 25709d8ee18..4558cfbdcc3 100644
--- a/src/plugins/platforms/windows/qwindowsfontenginedirectwrite.h
+++ b/src/plugins/platforms/windows/qwindowsfontenginedirectwrite.h
@@ -65,7 +65,7 @@ public:
                                     const QSharedPointer<QWindowsFontEngineData> &d);
     ~QWindowsFontEngineDirectWrite();
 
-    void initFontInfo(const QFontDef &request, int dpi, IDWriteFont *font);
+    void initFontInfo(const QFontDef &request, int dpi);
 
     QFixed lineThickness() const Q_DECL_OVERRIDE;
     QFixed underlinePosition() const Q_DECL_OVERRIDE;
diff --git a/src/plugins/platforms/windows/qwindowsglcontext.cpp b/src/plugins/platforms/windows/qwindowsglcontext.cpp
index 48f2e3aaef1..cc2f05b6d17 100644
--- a/src/plugins/platforms/windows/qwindowsglcontext.cpp
+++ b/src/plugins/platforms/windows/qwindowsglcontext.cpp
@@ -156,8 +156,6 @@ void *QWindowsOpengl32DLL::resolve(const char *name)
 #else
     void *proc = m_lib ? (void *) ::GetProcAddress(m_lib, (const wchar_t *) QString::fromLatin1(name).utf16()) : 0;
 #endif
-    if (!proc)
-        qErrnoWarning(::GetLastError(), "Failed to resolve OpenGL function %s", name);
 
     return proc;
 }
@@ -199,56 +197,11 @@ bool QWindowsOpengl32DLL::init(bool softwareRendering)
     wglSwapBuffers = reinterpret_cast<BOOL (WINAPI *)(HDC)>(resolve("wglSwapBuffers"));
     wglSetPixelFormat = reinterpret_cast<BOOL (WINAPI *)(HDC, int, const PIXELFORMATDESCRIPTOR *)>(resolve("wglSetPixelFormat"));
 
-    glBindTexture = reinterpret_cast<void (APIENTRY *)(GLenum , GLuint )>(resolve("glBindTexture"));
-    glBlendFunc = reinterpret_cast<void (APIENTRY *)(GLenum , GLenum )>(resolve("glBlendFunc"));
-    glClear = reinterpret_cast<void (APIENTRY *)(GLbitfield )>(resolve("glClear"));
-    glClearColor = reinterpret_cast<void (APIENTRY *)(GLfloat , GLfloat , GLfloat , GLfloat )>(resolve("glClearColor"));
-    glClearStencil = reinterpret_cast<void (APIENTRY *)(GLint )>(resolve("glClearStencil"));
-    glColorMask = reinterpret_cast<void (APIENTRY *)(GLboolean , GLboolean , GLboolean , GLboolean )>(resolve("glColorMask"));
-    glCopyTexImage2D = reinterpret_cast<void (APIENTRY *)(GLenum , GLint , GLenum , GLint , GLint , GLsizei , GLsizei , GLint )>(resolve("glCopyTexImage2D"));
-    glCopyTexSubImage2D = reinterpret_cast<void (APIENTRY *)(GLenum , GLint , GLint , GLint , GLint , GLint , GLsizei , GLsizei )>(resolve("glCopyTexSubImage2D"));
-    glCullFace = reinterpret_cast<void (APIENTRY *)(GLenum )>(resolve("glCullFace"));
-    glDeleteTextures = reinterpret_cast<void (APIENTRY *)(GLsizei , const GLuint *)>(resolve("glDeleteTextures"));
-    glDepthFunc = reinterpret_cast<void (APIENTRY *)(GLenum )>(resolve("glDepthFunc"));
-    glDepthMask = reinterpret_cast<void (APIENTRY *)(GLboolean )>(resolve("glDepthMask"));
-    glDisable = reinterpret_cast<void (APIENTRY *)(GLenum )>(resolve("glDisable"));
-    glDrawArrays = reinterpret_cast<void (APIENTRY *)(GLenum , GLint , GLsizei )>(resolve("glDrawArrays"));
-    glDrawElements = reinterpret_cast<void (APIENTRY *)(GLenum , GLsizei , GLenum , const GLvoid *)>(resolve("glDrawElements"));
-    glEnable = reinterpret_cast<void (APIENTRY *)(GLenum )>(resolve("glEnable"));
-    glFinish = reinterpret_cast<void (APIENTRY *)()>(resolve("glFinish"));
-    glFlush = reinterpret_cast<void (APIENTRY *)()>(resolve("glFlush"));
-    glFrontFace = reinterpret_cast<void (APIENTRY *)(GLenum )>(resolve("glFrontFace"));
-    glGenTextures = reinterpret_cast<void (APIENTRY *)(GLsizei , GLuint *)>(resolve("glGenTextures"));
-    glGetBooleanv = reinterpret_cast<void (APIENTRY *)(GLenum , GLboolean *)>(resolve("glGetBooleanv"));
     glGetError = reinterpret_cast<GLenum (APIENTRY *)()>(resolve("glGetError"));
-    glGetFloatv = reinterpret_cast<void (APIENTRY *)(GLenum , GLfloat *)>(resolve("glGetFloatv"));
     glGetIntegerv = reinterpret_cast<void (APIENTRY *)(GLenum , GLint *)>(resolve("glGetIntegerv"));
     glGetString = reinterpret_cast<const GLubyte * (APIENTRY *)(GLenum )>(resolve("glGetString"));
-    glGetTexParameterfv = reinterpret_cast<void (APIENTRY *)(GLenum , GLenum , GLfloat *)>(resolve("glGetTexParameterfv"));
-    glGetTexParameteriv = reinterpret_cast<void (APIENTRY *)(GLenum , GLenum , GLint *)>(resolve("glGetTexParameteriv"));
-    glHint = reinterpret_cast<void (APIENTRY *)(GLenum , GLenum )>(resolve("glHint"));
-    glIsEnabled = reinterpret_cast<GLboolean (APIENTRY *)(GLenum )>(resolve("glIsEnabled"));
-    glIsTexture = reinterpret_cast<GLboolean (APIENTRY *)(GLuint )>(resolve("glIsTexture"));
-    glLineWidth = reinterpret_cast<void (APIENTRY *)(GLfloat )>(resolve("glLineWidth"));
-    glPixelStorei = reinterpret_cast<void (APIENTRY *)(GLenum , GLint )>(resolve("glPixelStorei"));
-    glPolygonOffset = reinterpret_cast<void (APIENTRY *)(GLfloat , GLfloat )>(resolve("glPolygonOffset"));
-    glReadPixels = reinterpret_cast<void (APIENTRY *)(GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , GLvoid *)>(resolve("glReadPixels"));
-    glScissor = reinterpret_cast<void (APIENTRY *)(GLint , GLint , GLsizei , GLsizei )>(resolve("glScissor"));
-    glStencilFunc = reinterpret_cast<void (APIENTRY *)(GLenum , GLint , GLuint )>(resolve("glStencilFunc"));
-    glStencilMask = reinterpret_cast<void (APIENTRY *)(GLuint )>(resolve("glStencilMask"));
-    glStencilOp = reinterpret_cast<void (APIENTRY *)(GLenum , GLenum , GLenum )>(resolve("glStencilOp"));
-    glTexImage2D = reinterpret_cast<void (APIENTRY *)(GLenum , GLint , GLint , GLsizei , GLsizei , GLint , GLenum , GLenum , const GLvoid *)>(resolve("glTexImage2D"));
-    glTexParameterf = reinterpret_cast<void (APIENTRY *)(GLenum , GLenum , GLfloat )>(resolve("glTexParameterf"));
-    glTexParameterfv = reinterpret_cast<void (APIENTRY *)(GLenum , GLenum , const GLfloat *)>(resolve("glTexParameterfv"));
-    glTexParameteri = reinterpret_cast<void (APIENTRY *)(GLenum , GLenum , GLint )>(resolve("glTexParameteri"));
-    glTexParameteriv = reinterpret_cast<void (APIENTRY *)(GLenum , GLenum , const GLint *)>(resolve("glTexParameteriv"));
-    glTexSubImage2D = reinterpret_cast<void (APIENTRY *)(GLenum , GLint , GLint , GLint , GLsizei , GLsizei , GLenum , GLenum , const GLvoid *)>(resolve("glTexSubImage2D"));
-    glViewport = reinterpret_cast<void (APIENTRY *)(GLint , GLint , GLsizei , GLsizei )>(resolve("glViewport"));
 
-    glClearDepth = reinterpret_cast<void (APIENTRY *)(GLdouble )>(resolve("glClearDepth"));
-    glDepthRange = reinterpret_cast<void (APIENTRY *)(GLdouble , GLdouble )>(resolve("glDepthRange"));
-
-    return wglCreateContext && glBindTexture && glClearDepth;
+    return wglCreateContext && glGetError && glGetString;
 }
 
 BOOL QWindowsOpengl32DLL::swapBuffers(HDC dc)
@@ -1381,80 +1334,25 @@ void QWindowsGLContext::doneCurrent()
     releaseDCs();
 }
 
-QFunctionPointer QWindowsGLContext::getProcAddress(const QByteArray &procName)
+QFunctionPointer QWindowsGLContext::getProcAddress(const char *procName)
 {
+    // Even though we use QFunctionPointer, it does not mean the function can be called.
+    // It will need to be cast to the proper function type with the correct calling
+    // convention. QFunctionPointer is nothing more than a glorified void* here.
+    QFunctionPointer procAddress = reinterpret_cast<QFunctionPointer>(QOpenGLStaticContext::opengl32.wglGetProcAddress(procName));
+
     // We support AllGLFunctionsQueryable, which means this function must be able to
     // return a function pointer even for functions that are in GL.h and exported
     // normally from opengl32.dll. wglGetProcAddress() is not guaranteed to work for such
     // functions, however in QT_OPENGL_DYNAMIC builds QOpenGLFunctions will just blindly
-    // call into here for _any_ OpenGL function. Hence the need to handle these specially
-    // here. The list has to match QOpenGLFunctions. See
-    // QOpenGLFunctionsPrivate::QOpenGLFunctionsPrivate(QOpenGLContext *).
-    static struct StdFunc {
-        const char *name;
-        void *func;
-    } standardFuncs[] = {
-        { "glBindTexture", (void *) QOpenGLStaticContext::opengl32.glBindTexture },
-        { "glBlendFunc", (void *) QOpenGLStaticContext::opengl32.glBlendFunc },
-        { "glClear", (void *) QOpenGLStaticContext::opengl32.glClear },
-        { "glClearColor", (void *) QOpenGLStaticContext::opengl32.glClearColor },
-        { "glClearStencil", (void *) QOpenGLStaticContext::opengl32.glClearStencil },
-        { "glColorMask", (void *) QOpenGLStaticContext::opengl32.glColorMask },
-        { "glCopyTexImage2D", (void *) QOpenGLStaticContext::opengl32.glCopyTexImage2D },
-        { "glCopyTexSubImage2D", (void *) QOpenGLStaticContext::opengl32.glCopyTexSubImage2D },
-        { "glCullFace", (void *) QOpenGLStaticContext::opengl32.glCullFace },
-        { "glDeleteTextures", (void *) QOpenGLStaticContext::opengl32.glDeleteTextures },
-        { "glDepthFunc", (void *) QOpenGLStaticContext::opengl32.glDepthFunc },
-        { "glDepthMask", (void *) QOpenGLStaticContext::opengl32.glDepthMask },
-        { "glDisable", (void *) QOpenGLStaticContext::opengl32.glDisable },
-        { "glDrawArrays", (void *) QOpenGLStaticContext::opengl32.glDrawArrays },
-        { "glDrawElements", (void *) QOpenGLStaticContext::opengl32.glDrawElements },
-        { "glEnable", (void *) QOpenGLStaticContext::opengl32.glEnable },
-        { "glFinish", (void *) QOpenGLStaticContext::opengl32.glFinish },
-        { "glFlush", (void *) QOpenGLStaticContext::opengl32.glFlush },
-        { "glFrontFace", (void *) QOpenGLStaticContext::opengl32.glFrontFace },
-        { "glGenTextures", (void *) QOpenGLStaticContext::opengl32.glGenTextures },
-        { "glGetBooleanv", (void *) QOpenGLStaticContext::opengl32.glGetBooleanv },
-        { "glGetError", (void *) QOpenGLStaticContext::opengl32.glGetError },
-        { "glGetFloatv", (void *) QOpenGLStaticContext::opengl32.glGetFloatv },
-        { "glGetIntegerv", (void *) QOpenGLStaticContext::opengl32.glGetIntegerv },
-        { "glGetString", (void *) QOpenGLStaticContext::opengl32.glGetString },
-        { "glGetTexParameterfv", (void *) QOpenGLStaticContext::opengl32.glGetTexParameterfv },
-        { "glGetTexParameteriv", (void *) QOpenGLStaticContext::opengl32.glGetTexParameteriv },
-        { "glHint", (void *) QOpenGLStaticContext::opengl32.glHint },
-        { "glIsEnabled", (void *) QOpenGLStaticContext::opengl32.glIsEnabled },
-        { "glIsTexture", (void *) QOpenGLStaticContext::opengl32.glIsTexture },
-        { "glLineWidth", (void *) QOpenGLStaticContext::opengl32.glLineWidth },
-        { "glPixelStorei", (void *) QOpenGLStaticContext::opengl32.glPixelStorei },
-        { "glPolygonOffset", (void *) QOpenGLStaticContext::opengl32.glPolygonOffset },
-        { "glReadPixels", (void *) QOpenGLStaticContext::opengl32.glReadPixels },
-        { "glScissor", (void *) QOpenGLStaticContext::opengl32.glScissor },
-        { "glStencilFunc", (void *) QOpenGLStaticContext::opengl32.glStencilFunc },
-        { "glStencilMask", (void *) QOpenGLStaticContext::opengl32.glStencilMask },
-        { "glStencilOp", (void *) QOpenGLStaticContext::opengl32.glStencilOp },
-        { "glTexImage2D", (void *) QOpenGLStaticContext::opengl32.glTexImage2D },
-        { "glTexParameterf", (void *) QOpenGLStaticContext::opengl32.glTexParameterf },
-        { "glTexParameterfv", (void *) QOpenGLStaticContext::opengl32.glTexParameterfv },
-        { "glTexParameteri", (void *) QOpenGLStaticContext::opengl32.glTexParameteri },
-        { "glTexParameteriv", (void *) QOpenGLStaticContext::opengl32.glTexParameteriv },
-        { "glTexSubImage2D", (void *) QOpenGLStaticContext::opengl32.glTexSubImage2D },
-        { "glViewport", (void *) QOpenGLStaticContext::opengl32.glViewport },
+    // call into here for _any_ OpenGL function.
+    if (!procAddress || procAddress == reinterpret_cast<void *>(0x1) || procAddress == reinterpret_cast<void *>(0x2)
+        || procAddress == reinterpret_cast<void *>(0x3) || procAddress == reinterpret_cast<void *>(-1))
+        procAddress = reinterpret_cast<QFunctionPointer>(QOpenGLStaticContext::opengl32.resolve(procName));
 
-        { "glClearDepth", (void *) QOpenGLStaticContext::opengl32.glClearDepth },
-        { "glDepthRange", (void *) QOpenGLStaticContext::opengl32.glDepthRange },
-    };
-    for (size_t i = 0; i < sizeof(standardFuncs) / sizeof(StdFunc); ++i)
-        if (procName == standardFuncs[i].name)
-            return reinterpret_cast<QFunctionPointer>(standardFuncs[i].func);
-
-    // Even though we use QFunctionPointer, it does not mean the function can be called.
-    // It will need to be cast to the proper function type with the correct calling
-    // convention. QFunctionPointer is nothing more than a glorified void* here.
-    QFunctionPointer procAddress = reinterpret_cast<QFunctionPointer>(QOpenGLStaticContext::opengl32.wglGetProcAddress(procName.constData()));
     if (QWindowsContext::verbose > 1)
         qCDebug(lcQpaGl) << __FUNCTION__ <<  procName << QOpenGLStaticContext::opengl32.wglGetCurrentContext() << "returns" << procAddress;
-    if (!procAddress && QWindowsContext::verbose)
-        qWarning("%s: Unable to resolve '%s'", __FUNCTION__, procName.constData());
+
     return procAddress;
 }
 
diff --git a/src/plugins/platforms/windows/qwindowsglcontext.h b/src/plugins/platforms/windows/qwindowsglcontext.h
index 3acfed1ccf7..e8c78860f2d 100644
--- a/src/plugins/platforms/windows/qwindowsglcontext.h
+++ b/src/plugins/platforms/windows/qwindowsglcontext.h
@@ -118,58 +118,12 @@ struct QWindowsOpengl32DLL
     BOOL (WINAPI * wglShareLists)(HGLRC context1, HGLRC context2);
 
     // GL1+GLES2 common
-    void (APIENTRY * glBindTexture)(GLenum target, GLuint texture);
-    void (APIENTRY * glBlendFunc)(GLenum sfactor, GLenum dfactor);
-    void (APIENTRY * glClear)(GLbitfield mask);
-    void (APIENTRY * glClearColor)(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
-    void (APIENTRY * glClearStencil)(GLint s);
-    void (APIENTRY * glColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
-    void (APIENTRY * glCopyTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border);
-    void (APIENTRY * glCopyTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height);
-    void (APIENTRY * glCullFace)(GLenum mode);
-    void (APIENTRY * glDeleteTextures)(GLsizei n, const GLuint* textures);
-    void (APIENTRY * glDepthFunc)(GLenum func);
-    void (APIENTRY * glDepthMask)(GLboolean flag);
-    void (APIENTRY * glDisable)(GLenum cap);
-    void (APIENTRY * glDrawArrays)(GLenum mode, GLint first, GLsizei count);
-    void (APIENTRY * glDrawElements)(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices);
-    void (APIENTRY * glEnable)(GLenum cap);
-    void (APIENTRY * glFinish)();
-    void (APIENTRY * glFlush)();
-    void (APIENTRY * glFrontFace)(GLenum mode);
-    void (APIENTRY * glGenTextures)(GLsizei n, GLuint* textures);
-    void (APIENTRY * glGetBooleanv)(GLenum pname, GLboolean* params);
     GLenum (APIENTRY * glGetError)();
-    void (APIENTRY * glGetFloatv)(GLenum pname, GLfloat* params);
     void (APIENTRY * glGetIntegerv)(GLenum pname, GLint* params);
     const GLubyte * (APIENTRY * glGetString)(GLenum name);
-    void (APIENTRY * glGetTexParameterfv)(GLenum target, GLenum pname, GLfloat* params);
-    void (APIENTRY * glGetTexParameteriv)(GLenum target, GLenum pname, GLint* params);
-    void (APIENTRY * glHint)(GLenum target, GLenum mode);
-    GLboolean (APIENTRY * glIsEnabled)(GLenum cap);
-    GLboolean (APIENTRY * glIsTexture)(GLuint texture);
-    void (APIENTRY * glLineWidth)(GLfloat width);
-    void (APIENTRY * glPixelStorei)(GLenum pname, GLint param);
-    void (APIENTRY * glPolygonOffset)(GLfloat factor, GLfloat units);
-    void (APIENTRY * glReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels);
-    void (APIENTRY * glScissor)(GLint x, GLint y, GLsizei width, GLsizei height);
-    void (APIENTRY * glStencilFunc)(GLenum func, GLint ref, GLuint mask);
-    void (APIENTRY * glStencilMask)(GLuint mask);
-    void (APIENTRY * glStencilOp)(GLenum fail, GLenum zfail, GLenum zpass);
-    void (APIENTRY * glTexImage2D)(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels);
-    void (APIENTRY * glTexParameterf)(GLenum target, GLenum pname, GLfloat param);
-    void (APIENTRY * glTexParameterfv)(GLenum target, GLenum pname, const GLfloat* params);
-    void (APIENTRY * glTexParameteri)(GLenum target, GLenum pname, GLint param);
-    void (APIENTRY * glTexParameteriv)(GLenum target, GLenum pname, const GLint* params);
-    void (APIENTRY * glTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels);
-    void (APIENTRY * glViewport)(GLint x, GLint y, GLsizei width, GLsizei height);
 
-    // GL only
-    void (APIENTRY * glClearDepth)(GLdouble depth);
-    void (APIENTRY * glDepthRange)(GLdouble zNear, GLdouble zFar);
-
-private:
     void *resolve(const char *name);
+private:
     HMODULE m_lib;
     bool m_nonOpengl32;
 
@@ -251,7 +205,7 @@ public:
 
     typedef void (*GL_Proc) ();
 
-    QFunctionPointer getProcAddress(const QByteArray &procName) Q_DECL_OVERRIDE;
+    QFunctionPointer getProcAddress(const char *procName) Q_DECL_OVERRIDE;
 
     HGLRC renderingContext() const { return m_renderingContext; }
 
diff --git a/src/plugins/platforms/windows/qwindowskeymapper.cpp b/src/plugins/platforms/windows/qwindowskeymapper.cpp
index 48de7d56f82..5b2370b69dd 100644
--- a/src/plugins/platforms/windows/qwindowskeymapper.cpp
+++ b/src/plugins/platforms/windows/qwindowskeymapper.cpp
@@ -1253,7 +1253,12 @@ QList<int> QWindowsKeyMapper::possibleKeys(const QKeyEvent *e) const
 {
     QList<int> result;
 
-    const KeyboardLayoutItem &kbItem = keyLayout[e->nativeVirtualKey()];
+
+    const quint32 nativeVirtualKey = e->nativeVirtualKey();
+    if (nativeVirtualKey > 255)
+        return result;
+
+    const KeyboardLayoutItem &kbItem = keyLayout[nativeVirtualKey];
     if (!kbItem.exists)
         return result;
 
diff --git a/src/plugins/platforms/windows/qwindowstabletsupport.cpp b/src/plugins/platforms/windows/qwindowstabletsupport.cpp
index 8db6895999b..3689978b415 100644
--- a/src/plugins/platforms/windows/qwindowstabletsupport.cpp
+++ b/src/plugins/platforms/windows/qwindowstabletsupport.cpp
@@ -208,7 +208,7 @@ QWindowsTabletSupport *QWindowsTabletSupport::create()
     if (currentQueueSize != TabletPacketQSize) {
         if (!QWindowsTabletSupport::m_winTab32DLL.wTQueueSizeSet(context, TabletPacketQSize)) {
             if (!QWindowsTabletSupport::m_winTab32DLL.wTQueueSizeSet(context, currentQueueSize))  {
-                qWarning() << "Unable to set queue size on tablet. The tablet will not work.";
+                qWarning("Unable to set queue size on tablet. The tablet will not work.");
                 QWindowsTabletSupport::m_winTab32DLL.wTClose(context);
                 DestroyWindow(window);
                 return 0;
diff --git a/src/plugins/platforms/windows/qwindowswindow.cpp b/src/plugins/platforms/windows/qwindowswindow.cpp
index 4a665c15ad4..cb48e139343 100644
--- a/src/plugins/platforms/windows/qwindowswindow.cpp
+++ b/src/plugins/platforms/windows/qwindowswindow.cpp
@@ -700,7 +700,7 @@ void WindowCreationData::initialize(const QWindow *w, HWND hwnd, bool frameChang
         if ((flags & Qt::WindowStaysOnTopHint) || (type == Qt::ToolTip)) {
             SetWindowPos(hwnd, HWND_TOPMOST, 0, 0, 0, 0, swpFlags);
             if (flags & Qt::WindowStaysOnBottomHint)
-                qWarning() << "QWidget: Incompatible window flags: the window can't be on top and on bottom at the same time";
+                qWarning("QWidget: Incompatible window flags: the window can't be on top and on bottom at the same time");
         } else if (flags & Qt::WindowStaysOnBottomHint) {
             SetWindowPos(hwnd, HWND_BOTTOM, 0, 0, 0, 0, swpFlags);
         } else if (frameChange) { // Force WM_NCCALCSIZE with wParam=1 in case of custom margins.
@@ -1668,11 +1668,11 @@ void QWindowsWindow::releaseDC()
 bool QWindowsWindow::handleWmPaint(HWND hwnd, UINT message,
                                          WPARAM, LPARAM)
 {
+    if (message == WM_ERASEBKGND) // Backing store - ignored.
+        return true;
     // Ignore invalid update bounding rectangles
     if (!GetUpdateRect(m_data.hwnd, 0, FALSE))
         return false;
-    if (message == WM_ERASEBKGND) // Backing store - ignored.
-        return true;
     PAINTSTRUCT ps;
 
     // Observed painting problems with Aero style disabled (QTBUG-7865).
@@ -2211,7 +2211,7 @@ void QWindowsWindow::getSizeHints(MINMAXINFO *mmi) const
             mmi->ptMaxPosition.x = availableGeometry.x();
             mmi->ptMaxPosition.y = availableGeometry.y();
         } else if (!screen){
-            qWarning() << "window()->screen() returned a null screen";
+            qWarning("window()->screen() returned a null screen");
         }
     }
 
diff --git a/src/plugins/platforms/windows/windows.pro b/src/plugins/platforms/windows/windows.pro
index cc0373c0770..2e0f7236939 100644
--- a/src/plugins/platforms/windows/windows.pro
+++ b/src/plugins/platforms/windows/windows.pro
@@ -1,10 +1,5 @@
 TARGET = qwindows
 
-PLUGIN_TYPE = platforms
-PLUGIN_CLASS_NAME = QWindowsIntegrationPlugin
-!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
-load(qt_plugin)
-
 QT *= core-private
 QT *= gui-private
 QT *= platformsupport-private
@@ -25,3 +20,8 @@ HEADERS +=  \
     qwindowsgdinativeinterface.h
 
 OTHER_FILES += windows.json
+
+PLUGIN_TYPE = platforms
+PLUGIN_CLASS_NAME = QWindowsIntegrationPlugin
+!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
+load(qt_plugin)
diff --git a/src/plugins/platforms/winrt/qwinrteglcontext.cpp b/src/plugins/platforms/winrt/qwinrteglcontext.cpp
index 34f439b70f0..dfc9e31f14b 100644
--- a/src/plugins/platforms/winrt/qwinrteglcontext.cpp
+++ b/src/plugins/platforms/winrt/qwinrteglcontext.cpp
@@ -195,7 +195,7 @@ QSurfaceFormat QWinRTEGLContext::format() const
     return d->format;
 }
 
-QFunctionPointer QWinRTEGLContext::getProcAddress(const QByteArray &procName)
+QFunctionPointer QWinRTEGLContext::getProcAddress(const char *procName)
 {
     static QHash<QByteArray, QFunctionPointer> standardFuncs;
     if (standardFuncs.isEmpty()) {
@@ -347,7 +347,7 @@ QFunctionPointer QWinRTEGLContext::getProcAddress(const QByteArray &procName)
     if (i != standardFuncs.end())
         return i.value();
 
-    return eglGetProcAddress(procName.constData());
+    return eglGetProcAddress(procName);
 }
 
 EGLDisplay QWinRTEGLContext::display()
diff --git a/src/plugins/platforms/winrt/qwinrteglcontext.h b/src/plugins/platforms/winrt/qwinrteglcontext.h
index 49b289cd79d..6f38e2535d8 100644
--- a/src/plugins/platforms/winrt/qwinrteglcontext.h
+++ b/src/plugins/platforms/winrt/qwinrteglcontext.h
@@ -56,7 +56,7 @@ public:
     void swapBuffers(QPlatformSurface *windowSurface) Q_DECL_OVERRIDE;
 
     QSurfaceFormat format() const Q_DECL_OVERRIDE;
-    QFunctionPointer getProcAddress(const QByteArray &procName) Q_DECL_OVERRIDE;
+    QFunctionPointer getProcAddress(const char *procName) Q_DECL_OVERRIDE;
 
     static EGLDisplay display();
 private:
diff --git a/src/plugins/platforms/winrt/qwinrtscreen.cpp b/src/plugins/platforms/winrt/qwinrtscreen.cpp
index 4c4d553b2d7..47e68ae0afa 100644
--- a/src/plugins/platforms/winrt/qwinrtscreen.cpp
+++ b/src/plugins/platforms/winrt/qwinrtscreen.cpp
@@ -39,8 +39,10 @@
 #include "qwinrtbackingstore.h"
 #include "qwinrtinputcontext.h"
 #include "qwinrtcursor.h"
+#include "qwinrtwindow.h"
 #include <private/qeventdispatcher_winrt_p.h>
 
+#include <QtCore/QLoggingCategory>
 #include <QtGui/QSurfaceFormat>
 #include <QtGui/QGuiApplication>
 #include <qpa/qwindowsysteminterface.h>
@@ -469,6 +471,7 @@ QWinRTScreen::QWinRTScreen()
     : d_ptr(new QWinRTScreenPrivate)
 {
     Q_D(QWinRTScreen);
+    qCDebug(lcQpaWindows) << __FUNCTION__;
     d->orientation = Qt::PrimaryOrientation;
     d->touchDevice = Q_NULLPTR;
 
@@ -553,6 +556,7 @@ QWinRTScreen::QWinRTScreen()
 QWinRTScreen::~QWinRTScreen()
 {
     Q_D(QWinRTScreen);
+    qCDebug(lcQpaWindows) << __FUNCTION__ << this;
 
     // Unregister callbacks
     HRESULT hr;
@@ -631,6 +635,12 @@ QDpi QWinRTScreen::logicalDpi() const
     return QDpi(d->logicalDpi, d->logicalDpi);
 }
 
+qreal QWinRTScreen::pixelDensity() const
+{
+    Q_D(const QWinRTScreen);
+    return qRound(d->logicalDpi / 96);
+}
+
 qreal QWinRTScreen::scaleFactor() const
 {
     Q_D(const QWinRTScreen);
@@ -697,6 +707,8 @@ Xaml::IDependencyObject *QWinRTScreen::canvas() const
 void QWinRTScreen::setStatusBarVisibility(bool visible, QWindow *window)
 {
     Q_D(QWinRTScreen);
+    qCDebug(lcQpaWindows) << __FUNCTION__ << window << visible;
+
     const Qt::WindowFlags windowType = window->flags() & Qt::WindowType_Mask;
     if (!window || (windowType != Qt::Window && windowType != Qt::Dialog))
         return;
@@ -768,6 +780,7 @@ QWindow *QWinRTScreen::topWindow() const
 void QWinRTScreen::addWindow(QWindow *window)
 {
     Q_D(QWinRTScreen);
+    qCDebug(lcQpaWindows) << __FUNCTION__ << window;
     if (window == topWindow())
         return;
 
@@ -785,6 +798,7 @@ void QWinRTScreen::addWindow(QWindow *window)
 void QWinRTScreen::removeWindow(QWindow *window)
 {
     Q_D(QWinRTScreen);
+    qCDebug(lcQpaWindows) << __FUNCTION__ << window;
 
 #ifdef Q_OS_WINPHONE
     if (window->visibility() == QWindow::Minimized)
@@ -1131,6 +1145,7 @@ HRESULT QWinRTScreen::onSizeChanged(ICoreWindow *, IWindowSizeChangedEventArgs *
     hr = d->coreWindow->get_Bounds(&size);
     RETURN_OK_IF_FAILED("Failed to get window bounds");
     d->logicalSize = QSizeF(size.Width, size.Height);
+    qCDebug(lcQpaWindows) << __FUNCTION__ << d->logicalSize;
     QWindowSystemInterface::handleScreenGeometryChange(screen(), geometry(), availableGeometry());
     QPlatformScreen::resizeMaximizedWindows();
     handleExpose();
@@ -1140,6 +1155,7 @@ HRESULT QWinRTScreen::onSizeChanged(ICoreWindow *, IWindowSizeChangedEventArgs *
 HRESULT QWinRTScreen::onActivated(ICoreWindow *, IWindowActivatedEventArgs *args)
 {
     Q_D(QWinRTScreen);
+    qCDebug(lcQpaWindows) << __FUNCTION__;
 
     CoreWindowActivationState activationState;
     args->get_WindowActivationState(&activationState);
@@ -1159,6 +1175,8 @@ HRESULT QWinRTScreen::onActivated(ICoreWindow *, IWindowActivatedEventArgs *args
 
 HRESULT QWinRTScreen::onClosed(ICoreWindow *, ICoreWindowEventArgs *)
 {
+    qCDebug(lcQpaWindows) << __FUNCTION__;
+
     foreach (QWindow *w, QGuiApplication::topLevelWindows())
         QWindowSystemInterface::handleCloseEvent(w);
     return S_OK;
@@ -1170,6 +1188,7 @@ HRESULT QWinRTScreen::onVisibilityChanged(ICoreWindow *, IVisibilityChangedEvent
     boolean visible;
     HRESULT hr = args ? args->get_Visible(&visible) : d->coreWindow->get_Visible(&visible);
     RETURN_OK_IF_FAILED("Failed to get visibility.");
+    qCDebug(lcQpaWindows) << __FUNCTION__ << visible;
     QWindowSystemInterface::handleApplicationStateChanged(visible ? Qt::ApplicationActive : Qt::ApplicationHidden);
     if (visible)
         handleExpose();
@@ -1179,7 +1198,7 @@ HRESULT QWinRTScreen::onVisibilityChanged(ICoreWindow *, IVisibilityChangedEvent
 HRESULT QWinRTScreen::onOrientationChanged(IDisplayInformation *, IInspectable *)
 {
     Q_D(QWinRTScreen);
-
+    qCDebug(lcQpaWindows) << __FUNCTION__;
     DisplayOrientations displayOrientation;
     HRESULT hr = d->displayInformation->get_CurrentOrientation(&displayOrientation);
     RETURN_OK_IF_FAILED("Failed to get current orientations.");
@@ -1187,7 +1206,8 @@ HRESULT QWinRTScreen::onOrientationChanged(IDisplayInformation *, IInspectable *
     Qt::ScreenOrientation newOrientation = static_cast<Qt::ScreenOrientation>(static_cast<int>(qtOrientationsFromNative(displayOrientation)));
     if (d->orientation != newOrientation) {
         d->orientation = newOrientation;
-#ifdef Q_OS_WINPHONE
+        qCDebug(lcQpaWindows) << "  New orientation:" << newOrientation;
+#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PHONE_APP)
         onSizeChanged(nullptr, nullptr);
 #endif
         QWindowSystemInterface::handleScreenOrientationChange(screen(), d->orientation);
@@ -1211,6 +1231,8 @@ HRESULT QWinRTScreen::onDpiChanged(IDisplayInformation *, IInspectable *)
     hr = d->displayInformation->get_ResolutionScale(&resolutionScale);
     d->scaleFactor = qreal(resolutionScale) / 100;
 #endif
+    qCDebug(lcQpaWindows) << __FUNCTION__ << "Scale Factor:" << d->scaleFactor;
+
     RETURN_OK_IF_FAILED("Failed to get scale factor");
 
     FLOAT dpi;
@@ -1225,6 +1247,8 @@ HRESULT QWinRTScreen::onDpiChanged(IDisplayInformation *, IInspectable *)
     hr = d->displayInformation->get_RawDpiY(&dpi);
     RETURN_OK_IF_FAILED("Failed to get y raw DPI.");
     d->physicalDpi.second = dpi ? dpi : 96.0;
+    qCDebug(lcQpaWindows) << __FUNCTION__ << "Logical DPI:" << d->logicalDpi
+                          << "Physical DPI:" << d->physicalDpi;
 
     return S_OK;
 }
@@ -1232,12 +1256,14 @@ HRESULT QWinRTScreen::onDpiChanged(IDisplayInformation *, IInspectable *)
 #ifdef Q_OS_WINPHONE
 HRESULT QWinRTScreen::onStatusBarShowing(IStatusBar *, IInspectable *)
 {
+    qCDebug(lcQpaWindows) << __FUNCTION__;
     onSizeChanged(nullptr, nullptr);
     return S_OK;
 }
 
 HRESULT QWinRTScreen::onStatusBarHiding(IStatusBar *, IInspectable *)
 {
+    qCDebug(lcQpaWindows) << __FUNCTION__;
     onSizeChanged(nullptr, nullptr);
     return S_OK;
 }
diff --git a/src/plugins/platforms/winrt/qwinrtscreen.h b/src/plugins/platforms/winrt/qwinrtscreen.h
index 0043b2cfa3f..ac9db9bfef8 100644
--- a/src/plugins/platforms/winrt/qwinrtscreen.h
+++ b/src/plugins/platforms/winrt/qwinrtscreen.h
@@ -93,6 +93,7 @@ public:
     QImage::Format format() const Q_DECL_OVERRIDE;
     QSizeF physicalSize() const Q_DECL_OVERRIDE;
     QDpi logicalDpi() const Q_DECL_OVERRIDE;
+    qreal pixelDensity() const Q_DECL_OVERRIDE;
     qreal scaleFactor() const;
     QPlatformCursor *cursor() const Q_DECL_OVERRIDE;
     Qt::KeyboardModifiers keyboardModifiers() const;
diff --git a/src/plugins/platforms/winrt/winrt.pro b/src/plugins/platforms/winrt/winrt.pro
index 991ec1789b0..261295ef0b9 100644
--- a/src/plugins/platforms/winrt/winrt.pro
+++ b/src/plugins/platforms/winrt/winrt.pro
@@ -1,10 +1,6 @@
 TARGET = qwinrt
-CONFIG -= precompile_header
 
-PLUGIN_TYPE = platforms
-PLUGIN_CLASS_NAME = QWinRTIntegrationPlugin
-!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
-load(qt_plugin)
+CONFIG -= precompile_header
 
 QT += core-private gui-private platformsupport-private
 
@@ -50,3 +46,8 @@ HEADERS = \
     qwinrtwindow.h
 
 OTHER_FILES += winrt.json
+
+PLUGIN_TYPE = platforms
+PLUGIN_CLASS_NAME = QWinRTIntegrationPlugin
+!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
+load(qt_plugin)
diff --git a/src/plugins/platforms/xcb/gl_integrations/xcb_egl/xcb_egl.pro b/src/plugins/platforms/xcb/gl_integrations/xcb_egl/xcb_egl.pro
index 28a572a2c9e..6d52332bad0 100644
--- a/src/plugins/platforms/xcb/gl_integrations/xcb_egl/xcb_egl.pro
+++ b/src/plugins/platforms/xcb/gl_integrations/xcb_egl/xcb_egl.pro
@@ -1,10 +1,5 @@
 TARGET = qxcb-egl-integration
 
-PLUGIN_CLASS_NAME = QXcbEglIntegrationPlugin
-PLUGIN_TYPE = xcbglintegrations
-
-load(qt_plugin)
-
 include(../gl_integrations_plugin_base.pri)
 
 CONFIG += egl
@@ -22,3 +17,7 @@ SOURCES += \
     qxcbeglwindow.cpp \
     qxcbeglmain.cpp \
     qxcbeglnativeinterfacehandler.cpp
+
+PLUGIN_CLASS_NAME = QXcbEglIntegrationPlugin
+PLUGIN_TYPE = xcbglintegrations
+load(qt_plugin)
diff --git a/src/plugins/platforms/xcb/gl_integrations/xcb_glx/qglxintegration.cpp b/src/plugins/platforms/xcb/gl_integrations/xcb_glx/qglxintegration.cpp
index ff624d97551..4290ec54fc6 100644
--- a/src/plugins/platforms/xcb/gl_integrations/xcb_glx/qglxintegration.cpp
+++ b/src/plugins/platforms/xcb/gl_integrations/xcb_glx/qglxintegration.cpp
@@ -550,10 +550,10 @@ void QGLXContext::swapBuffers(QPlatformSurface *surface)
     }
 }
 
-void (*QGLXContext::getProcAddress(const QByteArray &procName)) ()
+QFunctionPointer QGLXContext::getProcAddress(const char *procName)
 {
 #ifdef QT_STATIC
-    return glXGetProcAddressARB(reinterpret_cast<const GLubyte *>(procName.constData()));
+    return glXGetProcAddressARB(reinterpret_cast<const GLubyte *>(procName));
 #else
     typedef void *(*qt_glXGetProcAddressARB)(const GLubyte *);
     static qt_glXGetProcAddressARB glXGetProcAddressARB = 0;
@@ -585,7 +585,7 @@ void (*QGLXContext::getProcAddress(const QByteArray &procName)) ()
     }
     if (!glXGetProcAddressARB)
         return 0;
-    return (void (*)())glXGetProcAddressARB(reinterpret_cast<const GLubyte *>(procName.constData()));
+    return (void (*)())glXGetProcAddressARB(reinterpret_cast<const GLubyte *>(procName));
 #endif
 }
 
diff --git a/src/plugins/platforms/xcb/gl_integrations/xcb_glx/qglxintegration.h b/src/plugins/platforms/xcb/gl_integrations/xcb_glx/qglxintegration.h
index e5cbee33631..f00d96e6d56 100644
--- a/src/plugins/platforms/xcb/gl_integrations/xcb_glx/qglxintegration.h
+++ b/src/plugins/platforms/xcb/gl_integrations/xcb_glx/qglxintegration.h
@@ -63,7 +63,7 @@ public:
     bool makeCurrent(QPlatformSurface *surface) Q_DECL_OVERRIDE;
     void doneCurrent() Q_DECL_OVERRIDE;
     void swapBuffers(QPlatformSurface *surface) Q_DECL_OVERRIDE;
-    QFunctionPointer getProcAddress(const QByteArray &procName) Q_DECL_OVERRIDE;
+    QFunctionPointer getProcAddress(const char *procName) Q_DECL_OVERRIDE;
 
     QSurfaceFormat format() const Q_DECL_OVERRIDE;
     bool isSharing() const Q_DECL_OVERRIDE;
diff --git a/src/plugins/platforms/xcb/gl_integrations/xcb_glx/xcb_glx.pro b/src/plugins/platforms/xcb/gl_integrations/xcb_glx/xcb_glx.pro
index 1c577e5dc96..67fd68765af 100644
--- a/src/plugins/platforms/xcb/gl_integrations/xcb_glx/xcb_glx.pro
+++ b/src/plugins/platforms/xcb/gl_integrations/xcb_glx/xcb_glx.pro
@@ -1,10 +1,5 @@
 TARGET = qxcb-glx-integration
 
-PLUGIN_CLASS_NAME = QXcbGlxIntegrationPlugin
-PLUGIN_TYPE = xcbglintegrations
-
-load(qt_plugin)
-
 include(../gl_integrations_plugin_base.pri)
 
 #should be removed from the sources
@@ -31,3 +26,7 @@ SOURCES += \
     qxcbglxwindow.cpp \
     qglxintegration.cpp \
     qxcbglxnativeinterfacehandler.cpp
+
+PLUGIN_CLASS_NAME = QXcbGlxIntegrationPlugin
+PLUGIN_TYPE = xcbglintegrations
+load(qt_plugin)
diff --git a/src/plugins/platforms/xcb/qxcbbackingstore.cpp b/src/plugins/platforms/xcb/qxcbbackingstore.cpp
index 3d22c9f4ddb..9ea1f5c33d5 100644
--- a/src/plugins/platforms/xcb/qxcbbackingstore.cpp
+++ b/src/plugins/platforms/xcb/qxcbbackingstore.cpp
@@ -74,13 +74,17 @@ public:
     QSize size() const { return m_qimage.size(); }
 
     bool hasAlpha() const { return m_hasAlpha; }
+    bool hasShm() const { return m_shm_info.shmaddr != nullptr; }
 
-    void put(xcb_window_t window, const QPoint &dst, const QRect &source);
+    void put(xcb_window_t window, const QRegion &region, const QPoint &offset);
     void preparePaint(const QRegion &region);
 
 private:
     void destroy();
 
+    void flushPixmap(const QRegion &region);
+    void setClip(const QRegion &region);
+
     xcb_shm_segment_info_t m_shm_info;
 
     xcb_image_t *m_xcb_image;
@@ -91,7 +95,15 @@ private:
     xcb_gcontext_t m_gc;
     xcb_window_t m_gc_window;
 
-    QRegion m_dirty;
+    // When using shared memory this is the region currently shared with the server
+    QRegion m_dirtyShm;
+
+    // When not using shared memory, we maintain a server-side pixmap with the backing
+    // store as well as repainted content not yet flushed to the pixmap. We only flush
+    // the regions we need and only when these are marked dirty. This way we can just
+    // do a server-side copy on expose instead of sending the pixels every time
+    xcb_pixmap_t m_xcb_pixmap;
+    QRegion m_pendingFlush;
 
     bool m_hasAlpha;
 };
@@ -131,17 +143,12 @@ QXcbShmImage::QXcbShmImage(QXcbScreen *screen, const QSize &size, uint depth, QI
     , m_graphics_buffer(Q_NULLPTR)
     , m_gc(0)
     , m_gc_window(0)
+    , m_xcb_pixmap(0)
 {
     Q_XCB_NOOP(connection());
 
-    const xcb_setup_t *setup = xcb_get_setup(xcb_connection());
-    xcb_format_t *fmt = xcb_setup_pixmap_formats(setup);
-    xcb_format_t *fmtend = fmt + xcb_setup_pixmap_formats_length(setup);
-    for (; fmt != fmtend; ++fmt)
-        if (fmt->depth == depth)
-            break;
-
-    Q_ASSERT(fmt != fmtend);
+    const xcb_format_t *fmt = connection()->formatForDepth(depth);
+    Q_ASSERT(fmt);
 
     m_xcb_image = xcb_image_create(size.width(), size.height(),
                                    XCB_IMAGE_FORMAT_Z_PIXMAP,
@@ -180,7 +187,7 @@ QXcbShmImage::QXcbShmImage(QXcbScreen *screen, const QSize &size, uint depth, QI
         m_xcb_image->data = (uint8_t *)malloc(segmentSize);
     } else {
         if (shmctl(m_shm_info.shmid, IPC_RMID, 0) == -1)
-            qWarning() << "QXcbBackingStore: Error while marking the shared memory segment to be destroyed";
+            qWarning("QXcbBackingStore: Error while marking the shared memory segment to be destroyed");
     }
 
     m_hasAlpha = QImage::toPixelFormat(format).alphaUsage() == QPixelFormat::UsesAlpha;
@@ -189,6 +196,15 @@ QXcbShmImage::QXcbShmImage(QXcbScreen *screen, const QSize &size, uint depth, QI
 
     m_qimage = QImage( (uchar*) m_xcb_image->data, m_xcb_image->width, m_xcb_image->height, m_xcb_image->stride, format);
     m_graphics_buffer = new QXcbShmGraphicsBuffer(&m_qimage);
+
+    if (!hasShm()) {
+        m_xcb_pixmap = xcb_generate_id(xcb_connection());
+        Q_XCB_CALL(xcb_create_pixmap(xcb_connection(),
+                                     m_xcb_image->depth,
+                                     m_xcb_pixmap,
+                                     screen->screen()->root,
+                                     m_xcb_image->width, m_xcb_image->height));
+    }
 }
 
 void QXcbShmImage::destroy()
@@ -212,95 +228,163 @@ void QXcbShmImage::destroy()
         Q_XCB_CALL(xcb_free_gc(xcb_connection(), m_gc));
     delete m_graphics_buffer;
     m_graphics_buffer = Q_NULLPTR;
+
+    if (m_xcb_pixmap) {
+        Q_XCB_CALL(xcb_free_pixmap(xcb_connection(), m_xcb_pixmap));
+        m_xcb_pixmap = 0;
+    }
 }
 
-void QXcbShmImage::put(xcb_window_t window, const QPoint &target, const QRect &source)
+void QXcbShmImage::flushPixmap(const QRegion &region)
 {
-    Q_XCB_NOOP(connection());
-    if (m_gc_window != window) {
-        if (m_gc)
-            Q_XCB_CALL(xcb_free_gc(xcb_connection(), m_gc));
-
-        m_gc = xcb_generate_id(xcb_connection());
-        Q_XCB_CALL(xcb_create_gc(xcb_connection(), m_gc, window, 0, 0));
-
-        m_gc_window = window;
-    }
-
-    Q_XCB_NOOP(connection());
-    if (m_shm_info.shmaddr) {
-        xcb_image_shm_put(xcb_connection(),
-                          window,
-                          m_gc,
-                          m_xcb_image,
-                          m_shm_info,
-                          source.x(),
-                          source.y(),
-                          target.x(),
-                          target.y(),
-                          source.width(),
-                          source.height(),
-                          false);
-    } else {
-        // If we upload the whole image in a single chunk, the result might be
-        // larger than the server's maximum request size and stuff breaks.
-        // To work around that, we upload the image in chunks where each chunk
-        // is small enough for a single request.
-        int src_x = source.x();
-        int src_y = source.y();
-        int target_x = target.x();
-        int target_y = target.y();
-        int width = source.width();
-        int height = source.height();
+    const QVector<QRect> rects = m_pendingFlush.intersected(region).rects();
+    m_pendingFlush -= region;
 
+    for (const QRect &rect : rects) {
         // We must make sure that each request is not larger than max_req_size.
         // Each request takes req_size + m_xcb_image->stride * height bytes.
-        uint32_t max_req_size = xcb_get_maximum_request_length(xcb_connection());
-        uint32_t req_size = sizeof(xcb_put_image_request_t);
-        int rows_per_put = (max_req_size - req_size) / m_xcb_image->stride;
+        static const uint32_t req_size = sizeof(xcb_put_image_request_t);
+        const uint32_t max_req_size = xcb_get_maximum_request_length(xcb_connection());
+        const int rows_per_put = (max_req_size - req_size) / m_xcb_image->stride;
 
         // This assert could trigger if a single row has more pixels than fit in
         // a single PutImage request. However, max_req_size is guaranteed to be
         // at least 16384 bytes. That should be enough for quite large images.
         Q_ASSERT(rows_per_put > 0);
 
-        // Convert the image to the native byte order.
-        xcb_image_t *converted_image = xcb_image_native(xcb_connection(), m_xcb_image, 1);
+        // If we upload the whole image in a single chunk, the result might be
+        // larger than the server's maximum request size and stuff breaks.
+        // To work around that, we upload the image in chunks where each chunk
+        // is small enough for a single request.
+        int src_x = rect.x();
+        int src_y = rect.y();
+        int target_x = rect.x();
+        int target_y = rect.y();
+        int width = rect.width();
+        int height = rect.height();
 
         while (height > 0) {
             int rows = std::min(height, rows_per_put);
 
-            xcb_image_t *subimage = xcb_image_subimage(converted_image, src_x, src_y, width, rows,
+            xcb_image_t *subimage = xcb_image_subimage(m_xcb_image, src_x, src_y, width, rows,
                                                        0, 0, 0);
+
+            // Convert the image to the native byte order.
+            xcb_image_t *native_subimage = xcb_image_native(xcb_connection(), subimage, 1);
+
             xcb_image_put(xcb_connection(),
-                          window,
+                          m_xcb_pixmap,
                           m_gc,
-                          subimage,
+                          native_subimage,
                           target_x,
                           target_y,
                           0);
 
+            if (native_subimage != subimage)
+                xcb_image_destroy(native_subimage);
+
             xcb_image_destroy(subimage);
 
             src_y += rows;
             target_y += rows;
             height -= rows;
         }
-
-        if (converted_image != m_xcb_image)
-            xcb_image_destroy(converted_image);
     }
+}
+
+void QXcbShmImage::setClip(const QRegion &region)
+{
+    if (region.isEmpty()) {
+        static const uint32_t mask = XCB_GC_CLIP_MASK;
+        static const uint32_t values[] = { XCB_NONE };
+        Q_XCB_CALL(xcb_change_gc(xcb_connection(),
+                                 m_gc,
+                                 mask,
+                                 values));
+    } else {
+        const QVector<QRect> qrects = region.rects();
+        QVector<xcb_rectangle_t> xcb_rects(qrects.size());
+
+        for (int i = 0; i < qrects.size(); i++) {
+            xcb_rects[i].x = qrects[i].x();
+            xcb_rects[i].y = qrects[i].y();
+            xcb_rects[i].width = qrects[i].width();
+            xcb_rects[i].height = qrects[i].height();
+        }
+
+        Q_XCB_CALL(xcb_set_clip_rectangles(xcb_connection(),
+                                           XCB_CLIP_ORDERING_YX_BANDED,
+                                           m_gc,
+                                           0, 0,
+                                           xcb_rects.size(), xcb_rects.constData()));
+    }
+}
+
+void QXcbShmImage::put(xcb_window_t window, const QRegion &region, const QPoint &offset)
+{
     Q_XCB_NOOP(connection());
 
-    m_dirty = m_dirty | source;
+    if (m_gc_window != window) {
+        if (m_gc)
+            Q_XCB_CALL(xcb_free_gc(xcb_connection(), m_gc));
+
+        static const uint32_t mask = XCB_GC_GRAPHICS_EXPOSURES;
+        static const uint32_t values[] = { 0 };
+
+        m_gc = xcb_generate_id(xcb_connection());
+        Q_XCB_CALL(xcb_create_gc(xcb_connection(), m_gc, window, mask, values));
+
+        m_gc_window = window;
+    }
+
+    Q_XCB_NOOP(connection());
+
+    setClip(region);
+
+    const QRect bounds = region.boundingRect();
+    const QPoint target = bounds.topLeft();
+    const QRect source = bounds.translated(offset);
+
+    if (hasShm()) {
+        Q_XCB_CALL(xcb_shm_put_image(xcb_connection(),
+                                     window,
+                                     m_gc,
+                                     m_xcb_image->width,
+                                     m_xcb_image->height,
+                                     source.x(), source.y(),
+                                     source.width(), source.height(),
+                                     target.x(), target.y(),
+                                     m_xcb_image->depth,
+                                     m_xcb_image->format,
+                                     0, // send event?
+                                     m_shm_info.shmseg,
+                                     m_xcb_image->data - m_shm_info.shmaddr));
+        m_dirtyShm |= region.translated(offset);
+    } else {
+        flushPixmap(region);
+        Q_XCB_CALL(xcb_copy_area(xcb_connection(),
+                                 m_xcb_pixmap,
+                                 window,
+                                 m_gc,
+                                 source.x(), source.y(),
+                                 target.x(), target.y(),
+                                 source.width(), source.height()));
+    }
+
+    setClip(QRegion());
+    Q_XCB_NOOP(connection());
 }
 
 void QXcbShmImage::preparePaint(const QRegion &region)
 {
-    // to prevent X from reading from the image region while we're writing to it
-    if (m_dirty.intersects(region)) {
-        connection()->sync();
-        m_dirty = QRegion();
+    if (hasShm()) {
+        // to prevent X from reading from the image region while we're writing to it
+        if (m_dirtyShm.intersects(region)) {
+            connection()->sync();
+            m_dirtyShm = QRegion();
+        }
+    } else {
+        m_pendingFlush |= region;
     }
 }
 
@@ -396,10 +480,7 @@ void QXcbBackingStore::flush(QWindow *window, const QRegion &region, const QPoin
         return;
     }
 
-    for (const QRect &r : clipped) {
-        QRect rect = QRect(r.topLeft(), r.size());
-        m_image->put(platformWindow->xcb_window(), rect.topLeft(), rect.translated(offset));
-    }
+    m_image->put(platformWindow->xcb_window(), clipped, offset);
 
     Q_XCB_NOOP(connection());
 
diff --git a/src/plugins/platforms/xcb/qxcbconnection.cpp b/src/plugins/platforms/xcb/qxcbconnection.cpp
index 998f4884aab..4fee772cd6d 100644
--- a/src/plugins/platforms/xcb/qxcbconnection.cpp
+++ b/src/plugins/platforms/xcb/qxcbconnection.cpp
@@ -1962,7 +1962,9 @@ static const char * xcb_atomnames = {
     "_COMPIZ_DECOR_PENDING\0"
     "_COMPIZ_DECOR_REQUEST\0"
     "_COMPIZ_DECOR_DELETE_PIXMAP\0"
-    "_COMPIZ_TOOLKIT_ACTION\0" // \0\0 terminates loop.
+    "_COMPIZ_TOOLKIT_ACTION\0"
+    "_GTK_LOAD_ICONTHEMES\0"
+    // \0\0 terminates loop.
 };
 
 QXcbAtom::Atom QXcbConnection::qatom(xcb_atom_t xatom) const
@@ -2173,7 +2175,7 @@ void QXcbConnection::initializeXKB()
 #ifndef QT_NO_XKB
     const xcb_query_extension_reply_t *reply = xcb_get_extension_data(m_connection, &xcb_xkb_id);
     if (!reply || !reply->present) {
-        qWarning() << "Qt: XKEYBOARD extension not present on the X server.";
+        qWarning("Qt: XKEYBOARD extension not present on the X server.");
         xkb_first_event = 0;
         return;
     }
@@ -2227,7 +2229,7 @@ void QXcbConnection::initializeXKB()
     xcb_generic_error_t *error = xcb_request_check(c, select);
     if (error) {
         free(error);
-        qWarning() << "Qt: failed to select notify events from xcb-xkb";
+        qWarning("Qt: failed to select notify events from xcb-xkb");
         return;
     }
 #endif
diff --git a/src/plugins/platforms/xcb/qxcbconnection.h b/src/plugins/platforms/xcb/qxcbconnection.h
index 02dc95e8529..9fed7b52f14 100644
--- a/src/plugins/platforms/xcb/qxcbconnection.h
+++ b/src/plugins/platforms/xcb/qxcbconnection.h
@@ -294,6 +294,7 @@ namespace QXcbAtom {
         _COMPIZ_DECOR_REQUEST,
         _COMPIZ_DECOR_DELETE_PIXMAP,
         _COMPIZ_TOOLKIT_ACTION,
+        _GTK_LOAD_ICONTHEMES,
 
         NPredefinedAtoms,
 
@@ -355,7 +356,7 @@ public:
     virtual void handleFocusOutEvent(const xcb_focus_out_event_t *) {}
     virtual void handlePropertyNotifyEvent(const xcb_property_notify_event_t *) {}
 #ifdef XCB_USE_XINPUT22
-    virtual void handleXIMouseEvent(xcb_ge_event_t *) {}
+    virtual void handleXIMouseEvent(xcb_ge_event_t *, Qt::MouseEventSource = Qt::MouseEventNotSynthesized) {}
     virtual void handleXIEnterLeave(xcb_ge_event_t *) {}
 #endif
     virtual QXcbWindow *toWindow() { return 0; }
diff --git a/src/plugins/platforms/xcb/qxcbconnection_xi2.cpp b/src/plugins/platforms/xcb/qxcbconnection_xi2.cpp
index e94433dd4b3..63a650a514c 100644
--- a/src/plugins/platforms/xcb/qxcbconnection_xi2.cpp
+++ b/src/plugins/platforms/xcb/qxcbconnection_xi2.cpp
@@ -1136,7 +1136,7 @@ bool QXcbConnection::xi2HandleTabletEvent(void *event, TabletData *tabletData, Q
     // Synthesize mouse events since otherwise there are no mouse events from
     // the pen on the XI 2.2+ path.
     if (xi2MouseEvents() && eventListener)
-        eventListener->handleXIMouseEvent(reinterpret_cast<xcb_ge_event_t *>(event));
+        eventListener->handleXIMouseEvent(reinterpret_cast<xcb_ge_event_t *>(event), Qt::MouseEventSynthesizedByQt);
 #else
     Q_UNUSED(eventListener);
 #endif
diff --git a/src/plugins/platforms/xcb/qxcbdrag.cpp b/src/plugins/platforms/xcb/qxcbdrag.cpp
index 9409de24067..ea20ef7a044 100644
--- a/src/plugins/platforms/xcb/qxcbdrag.cpp
+++ b/src/plugins/platforms/xcb/qxcbdrag.cpp
@@ -429,6 +429,7 @@ void QXcbDrag::move(const QPoint &globalPos)
 
             xcb_client_message_event_t enter;
             enter.response_type = XCB_CLIENT_MESSAGE;
+            enter.sequence = 0;
             enter.window = target;
             enter.format = 32;
             enter.type = atom(QXcbAtom::XdndEnter);
@@ -457,6 +458,7 @@ void QXcbDrag::move(const QPoint &globalPos)
 
         xcb_client_message_event_t move;
         move.response_type = XCB_CLIENT_MESSAGE;
+        move.sequence = 0;
         move.window = target;
         move.format = 32;
         move.type = atom(QXcbAtom::XdndPosition);
@@ -485,6 +487,7 @@ void QXcbDrag::drop(const QPoint &globalPos)
 
     xcb_client_message_event_t drop;
     drop.response_type = XCB_CLIENT_MESSAGE;
+    drop.sequence = 0;
     drop.window = current_target;
     drop.format = 32;
     drop.type = atom(QXcbAtom::XdndDrop);
@@ -746,6 +749,7 @@ void QXcbDrag::handle_xdnd_position(QPlatformWindow *w, const xcb_client_message
 
     xcb_client_message_event_t response;
     response.response_type = XCB_CLIENT_MESSAGE;
+    response.sequence = 0;
     response.window = xdnd_dragsource;
     response.format = 32;
     response.type = atom(QXcbAtom::XdndStatus);
@@ -892,6 +896,7 @@ void QXcbDrag::send_leave()
 
     xcb_client_message_event_t leave;
     leave.response_type = XCB_CLIENT_MESSAGE;
+    leave.sequence = 0;
     leave.window = current_target;
     leave.format = 32;
     leave.type = atom(QXcbAtom::XdndLeave);
@@ -962,6 +967,7 @@ void QXcbDrag::handleDrop(QPlatformWindow *, const xcb_client_message_event_t *e
 
     xcb_client_message_event_t finished;
     finished.response_type = XCB_CLIENT_MESSAGE;
+    finished.sequence = 0;
     finished.window = xdnd_dragsource;
     finished.format = 32;
     finished.type = atom(QXcbAtom::XdndFinished);
diff --git a/src/plugins/platforms/xcb/qxcbintegration.cpp b/src/plugins/platforms/xcb/qxcbintegration.cpp
index 6e8755a2206..b5e03e68fe1 100644
--- a/src/plugins/platforms/xcb/qxcbintegration.cpp
+++ b/src/plugins/platforms/xcb/qxcbintegration.cpp
@@ -164,7 +164,7 @@ QXcbIntegration::QXcbIntegration(const QStringList &parameters, int &argc, char
 
     bool underDebugger = runningUnderDebugger();
     if (noGrabArg && doGrabArg && underDebugger) {
-        qWarning() << "Both -nograb and -dograb command line arguments specified. Please pick one. -nograb takes prcedence";
+        qWarning("Both -nograb and -dograb command line arguments specified. Please pick one. -nograb takes prcedence");
         doGrabArg = false;
     }
 
@@ -203,7 +203,7 @@ QPlatformWindow *QXcbIntegration::createPlatformWindow(QWindow *window) const
 {
     QXcbScreen *screen = static_cast<QXcbScreen *>(window->screen()->handle());
     QXcbGlIntegration *glIntegration = screen->connection()->glIntegration();
-    if (window->type() != Qt::Desktop) {
+    if (window->type() != Qt::Desktop && window->supportsOpenGL()) {
         if (glIntegration) {
             QXcbWindow *xcbWindow = glIntegration->createWindow(window);
             xcbWindow->create();
diff --git a/src/plugins/platforms/xcb/qxcbkeyboard.cpp b/src/plugins/platforms/xcb/qxcbkeyboard.cpp
index 4de7716703b..a16e24061c5 100644
--- a/src/plugins/platforms/xcb/qxcbkeyboard.cpp
+++ b/src/plugins/platforms/xcb/qxcbkeyboard.cpp
@@ -676,13 +676,13 @@ void QXcbKeyboard::printKeymapError(const char *error) const
 {
     qWarning() << error;
     if (xkb_context) {
-        qWarning() << "Current XKB configuration data search paths are: ";
+        qWarning("Current XKB configuration data search paths are: ");
         for (unsigned int i = 0; i < xkb_context_num_include_paths(xkb_context); ++i)
             qWarning() << xkb_context_include_path_get(xkb_context, i);
     }
-    qWarning() << "Use QT_XKB_CONFIG_ROOT environmental variable to provide an additional search path, "
-                  "add ':' as separator to provide several search paths and/or make sure that XKB configuration data "
-                  "directory contains recent enough contents, to update please see http://cgit.freedesktop.org/xkeyboard-config/ .";
+    qWarning("Use QT_XKB_CONFIG_ROOT environmental variable to provide an additional search path, "
+             "add ':' as separator to provide several search paths and/or make sure that XKB configuration data "
+             "directory contains recent enough contents, to update please see http://cgit.freedesktop.org/xkeyboard-config/ .");
 }
 
 void QXcbKeyboard::updateKeymap()
diff --git a/src/plugins/platforms/xcb/qxcbnativeinterface.cpp b/src/plugins/platforms/xcb/qxcbnativeinterface.cpp
index 189053c5bf4..a8d401e15b0 100644
--- a/src/plugins/platforms/xcb/qxcbnativeinterface.cpp
+++ b/src/plugins/platforms/xcb/qxcbnativeinterface.cpp
@@ -55,6 +55,7 @@
 
 #include <QtPlatformHeaders/qxcbwindowfunctions.h>
 #include <QtPlatformHeaders/qxcbintegrationfunctions.h>
+#include <QtPlatformHeaders/qxcbscreenfunctions.h>
 
 #ifndef QT_NO_DBUS
 #include "QtPlatformSupport/private/qdbusmenuconnection_p.h"
@@ -83,9 +84,10 @@ static int resourceType(const QByteArray &key)
         QByteArrayLiteral("startupid"), QByteArrayLiteral("traywindow"),
         QByteArrayLiteral("gettimestamp"), QByteArrayLiteral("x11screen"),
         QByteArrayLiteral("rootwindow"),
-        QByteArrayLiteral("subpixeltype"), QByteArrayLiteral("antialiasingEnabled"),
+        QByteArrayLiteral("subpixeltype"), QByteArrayLiteral("antialiasingenabled"),
         QByteArrayLiteral("nofonthinting"),
-        QByteArrayLiteral("atspibus")
+        QByteArrayLiteral("atspibus"),
+        QByteArrayLiteral("compositingenabled")
     };
     const QByteArray *end = names + sizeof(names) / sizeof(names[0]);
     const QByteArray *result = std::find(names, end, key);
@@ -202,7 +204,7 @@ void *QXcbNativeInterface::nativeResourceForContext(const QByteArray &resourceSt
 void *QXcbNativeInterface::nativeResourceForScreen(const QByteArray &resourceString, QScreen *screen)
 {
     if (!screen) {
-        qWarning() << "nativeResourceForScreen: null screen";
+        qWarning("nativeResourceForScreen: null screen");
         return Q_NULLPTR;
     }
 
@@ -246,6 +248,10 @@ void *QXcbNativeInterface::nativeResourceForScreen(const QByteArray &resourceStr
     case RootWindow:
         result = reinterpret_cast<void *>(xcbScreen->root());
         break;
+    case CompositingEnabled:
+        if (QXcbVirtualDesktop *vd = xcbScreen->virtualDesktop())
+            result = vd->compositingActive() ? this : Q_NULLPTR;
+        break;
     default:
         break;
     }
@@ -376,6 +382,10 @@ QFunctionPointer QXcbNativeInterface::platformFunction(const QByteArray &functio
     if (function == QXcbWindowFunctions::visualIdIdentifier()) {
         return QFunctionPointer(QXcbWindowFunctions::VisualId(QXcbWindow::visualIdStatic));
     }
+
+    if (function == QXcbScreenFunctions::virtualDesktopNumberIdentifier())
+        return QFunctionPointer(QXcbScreenFunctions::VirtualDesktopNumber(QXcbScreen::virtualDesktopNumberStatic));
+
     return Q_NULLPTR;
 }
 
diff --git a/src/plugins/platforms/xcb/qxcbnativeinterface.h b/src/plugins/platforms/xcb/qxcbnativeinterface.h
index a3e188195fd..ba19cd869c0 100644
--- a/src/plugins/platforms/xcb/qxcbnativeinterface.h
+++ b/src/plugins/platforms/xcb/qxcbnativeinterface.h
@@ -74,7 +74,8 @@ public:
         ScreenSubpixelType,
         ScreenAntialiasingEnabled,
         NoFontHinting,
-        AtspiBus
+        AtspiBus,
+        CompositingEnabled
     };
 
     QXcbNativeInterface();
diff --git a/src/plugins/platforms/xcb/qxcbscreen.cpp b/src/plugins/platforms/xcb/qxcbscreen.cpp
index 339529edf17..67a9b2f190e 100644
--- a/src/plugins/platforms/xcb/qxcbscreen.cpp
+++ b/src/plugins/platforms/xcb/qxcbscreen.cpp
@@ -367,6 +367,7 @@ void QXcbScreen::sendStartupMessage(const QByteArray &message) const
     ev.response_type = XCB_CLIENT_MESSAGE;
     ev.format = 8;
     ev.type = connection()->atom(QXcbAtom::_NET_STARTUP_INFO_BEGIN);
+    ev.sequence = 0;
     ev.window = rootWindow;
     int sent = 0;
     int length = message.length() + 1; // include NUL byte
@@ -444,6 +445,14 @@ void QXcbScreen::setOutput(xcb_randr_output_t outputId,
     // TODO: Send an event to the QScreen instance that the screen changed its name
 }
 
+int QXcbScreen::virtualDesktopNumberStatic(const QScreen *screen)
+{
+    if (screen && screen->handle())
+        return static_cast<const QXcbScreen *>(screen->handle())->screenNumber();
+
+    return 0;
+}
+
 /*!
     \brief handle the XCB screen change event and update properties
 
diff --git a/src/plugins/platforms/xcb/qxcbscreen.h b/src/plugins/platforms/xcb/qxcbscreen.h
index e97631e2afd..30c5073459e 100644
--- a/src/plugins/platforms/xcb/qxcbscreen.h
+++ b/src/plugins/platforms/xcb/qxcbscreen.h
@@ -139,6 +139,7 @@ public:
     bool isPrimary() const { return m_primary; }
 
     int screenNumber() const { return m_virtualDesktop->number(); }
+    static int virtualDesktopNumberStatic(const QScreen *screen);
 
     xcb_screen_t *screen() const { return m_virtualDesktop->screen(); }
     xcb_window_t root() const { return screen()->root; }
diff --git a/src/plugins/platforms/xcb/qxcbsystemtraytracker.cpp b/src/plugins/platforms/xcb/qxcbsystemtraytracker.cpp
index cfed556ec98..5522af86def 100644
--- a/src/plugins/platforms/xcb/qxcbsystemtraytracker.cpp
+++ b/src/plugins/platforms/xcb/qxcbsystemtraytracker.cpp
@@ -100,9 +100,9 @@ xcb_window_t QXcbSystemTrayTracker::locateTrayWindow(const QXcbConnection *conne
 void QXcbSystemTrayTracker::requestSystemTrayWindowDock(xcb_window_t window) const
 {
     xcb_client_message_event_t trayRequest;
-    memset(&trayRequest, 0, sizeof(trayRequest));
     trayRequest.response_type = XCB_CLIENT_MESSAGE;
     trayRequest.format = 32;
+    trayRequest.sequence = 0;
     trayRequest.window = m_trayWindow;
     trayRequest.type = m_trayAtom;
     trayRequest.data.data32[0] = XCB_CURRENT_TIME;
diff --git a/src/plugins/platforms/xcb/qxcbwindow.cpp b/src/plugins/platforms/xcb/qxcbwindow.cpp
index c910ec18ed3..a426e04721e 100644
--- a/src/plugins/platforms/xcb/qxcbwindow.cpp
+++ b/src/plugins/platforms/xcb/qxcbwindow.cpp
@@ -40,6 +40,7 @@
 #include "qxcbwindow.h"
 
 #include <QtDebug>
+#include <QMetaEnum>
 #include <QScreen>
 #include <QtGui/QIcon>
 #include <QtGui/QRegion>
@@ -201,6 +202,20 @@ static inline QImage::Format imageFormatForVisual(int depth, quint32 red_mask, q
     case 16:
         if (blue_mask == 0x1f)
             return QImage::Format_RGB16;
+        if (red_mask == 0x1f) {
+            if (rgbSwap)
+                *rgbSwap = true;
+            return QImage::Format_RGB16;
+        }
+        break;
+    case 15:
+        if (blue_mask == 0x1f)
+            return QImage::Format_RGB555;
+        if (red_mask == 0x1f) {
+            if (rgbSwap)
+                *rgbSwap = true;
+            return QImage::Format_RGB555;
+        }
         break;
     default:
         break;
@@ -358,7 +373,7 @@ void QXcbWindow::create()
             if (visual)
                 m_visualId = connection()->defaultVisualId();
             if (!visual)
-                qWarning() << "Could not use default visual id. Falling back to root_visual for screen.";
+                qWarning("Could not use default visual id. Falling back to root_visual for screen.");
         }
         if (!visual)
             visual = platformScreen->visualForId(m_visualId);
@@ -1096,21 +1111,37 @@ QXcbWindow::NetWmStates QXcbWindow::netWmStates()
 void QXcbWindow::setNetWmStates(NetWmStates states)
 {
     QVector<xcb_atom_t> atoms;
-    if (states & NetWmStateAbove)
+
+    xcb_get_property_cookie_t get_cookie =
+        xcb_get_property_unchecked(xcb_connection(), 0, m_window, atom(QXcbAtom::_NET_WM_STATE),
+                         XCB_ATOM_ATOM, 0, 1024);
+
+    xcb_get_property_reply_t *reply =
+        xcb_get_property_reply(xcb_connection(), get_cookie, NULL);
+
+    if (reply && reply->format == 32 && reply->type == XCB_ATOM_ATOM && reply->value_len > 0) {
+        const xcb_atom_t *data = static_cast<const xcb_atom_t *>(xcb_get_property_value(reply));
+        atoms.resize(reply->value_len);
+        memcpy((void *)&atoms.first(), (void *)data, reply->value_len * sizeof(xcb_atom_t));
+    }
+
+    free(reply);
+
+    if (states & NetWmStateAbove && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_ABOVE)))
         atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_ABOVE));
-    if (states & NetWmStateBelow)
+    if (states & NetWmStateBelow && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_BELOW)))
         atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_BELOW));
-    if (states & NetWmStateFullScreen)
+    if (states & NetWmStateFullScreen && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_FULLSCREEN)))
         atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_FULLSCREEN));
-    if (states & NetWmStateMaximizedHorz)
+    if (states & NetWmStateMaximizedHorz && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_HORZ)))
         atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_HORZ));
-    if (states & NetWmStateMaximizedVert)
+    if (states & NetWmStateMaximizedVert && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_VERT)))
         atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_MAXIMIZED_VERT));
-    if (states & NetWmStateModal)
+    if (states & NetWmStateModal && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_MODAL)))
         atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_MODAL));
-    if (states & NetWmStateStaysOnTop)
+    if (states & NetWmStateStaysOnTop && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_STAYS_ON_TOP)))
         atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_STAYS_ON_TOP));
-    if (states & NetWmStateDemandsAttention)
+    if (states & NetWmStateDemandsAttention && !atoms.contains(atom(QXcbAtom::_NET_WM_STATE_DEMANDS_ATTENTION)))
         atoms.push_back(atom(QXcbAtom::_NET_WM_STATE_DEMANDS_ATTENTION));
 
     if (atoms.isEmpty()) {
@@ -1230,6 +1261,7 @@ void QXcbWindow::changeNetWmState(bool set, xcb_atom_t one, xcb_atom_t two)
 
     event.response_type = XCB_CLIENT_MESSAGE;
     event.format = 32;
+    event.sequence = 0;
     event.window = m_window;
     event.type = atom(QXcbAtom::_NET_WM_STATE);
     event.data.data32[0] = set ? 1 : 0;
@@ -1271,6 +1303,7 @@ void QXcbWindow::setWindowState(Qt::WindowState state)
 
             event.response_type = XCB_CLIENT_MESSAGE;
             event.format = 32;
+            event.sequence = 0;
             event.window = m_window;
             event.type = atom(QXcbAtom::WM_CHANGE_STATE);
             event.data.data32[0] = XCB_WM_STATE_ICONIC;
@@ -1675,6 +1708,7 @@ void QXcbWindow::requestActivateWindow()
 
         event.response_type = XCB_CLIENT_MESSAGE;
         event.format = 32;
+        event.sequence = 0;
         event.window = m_window;
         event.type = atom(QXcbAtom::_NET_ACTIVE_WINDOW);
         event.data.data32[0] = 1;
@@ -2049,8 +2083,9 @@ void QXcbWindow::handleClientMessageEvent(const xcb_client_message_event_t *even
     } else if (event->type == atom(QXcbAtom::_COMPIZ_DECOR_PENDING)
             || event->type == atom(QXcbAtom::_COMPIZ_DECOR_REQUEST)
             || event->type == atom(QXcbAtom::_COMPIZ_DECOR_DELETE_PIXMAP)
-            || event->type == atom(QXcbAtom::_COMPIZ_TOOLKIT_ACTION)) {
-        //silence the _COMPIZ messages for now
+            || event->type == atom(QXcbAtom::_COMPIZ_TOOLKIT_ACTION)
+            || event->type == atom(QXcbAtom::_GTK_LOAD_ICONTHEMES)) {
+        //silence the _COMPIZ and _GTK messages for now
     } else {
         qWarning() << "QXcbWindow: Unhandled client message:" << connection()->atomName(event->type);
     }
@@ -2171,7 +2206,7 @@ void QXcbWindow::handleUnmapNotifyEvent(const xcb_unmap_notify_event_t *event)
 }
 
 void QXcbWindow::handleButtonPressEvent(int event_x, int event_y, int root_x, int root_y,
-                                        int detail, Qt::KeyboardModifiers modifiers, xcb_timestamp_t timestamp)
+                                        int detail, Qt::KeyboardModifiers modifiers, xcb_timestamp_t timestamp, Qt::MouseEventSource source)
 {
     const bool isWheel = detail >= 4 && detail <= 7;
     if (!isWheel && window() != QGuiApplication::focusWindow()) {
@@ -2207,11 +2242,11 @@ void QXcbWindow::handleButtonPressEvent(int event_x, int event_y, int root_x, in
         return;
     }
 
-    handleMouseEvent(timestamp, local, global, modifiers);
+    handleMouseEvent(timestamp, local, global, modifiers, source);
 }
 
 void QXcbWindow::handleButtonReleaseEvent(int event_x, int event_y, int root_x, int root_y,
-                                          int detail, Qt::KeyboardModifiers modifiers, xcb_timestamp_t timestamp)
+                                          int detail, Qt::KeyboardModifiers modifiers, xcb_timestamp_t timestamp, Qt::MouseEventSource source)
 {
     QPoint local(event_x, event_y);
     QPoint global(root_x, root_y);
@@ -2221,7 +2256,7 @@ void QXcbWindow::handleButtonReleaseEvent(int event_x, int event_y, int root_x,
         return;
     }
 
-    handleMouseEvent(timestamp, local, global, modifiers);
+    handleMouseEvent(timestamp, local, global, modifiers, source);
 }
 
 static bool ignoreLeaveEvent(quint8 mode, quint8 detail)
@@ -2304,11 +2339,11 @@ void QXcbWindow::handleLeaveNotifyEvent(int root_x, int root_y,
 }
 
 void QXcbWindow::handleMotionNotifyEvent(int event_x, int event_y, int root_x, int root_y,
-                                         Qt::KeyboardModifiers modifiers, xcb_timestamp_t timestamp)
+                                         Qt::KeyboardModifiers modifiers, xcb_timestamp_t timestamp, Qt::MouseEventSource source)
 {
     QPoint local(event_x, event_y);
     QPoint global(root_x, root_y);
-    handleMouseEvent(timestamp, local, global, modifiers);
+    handleMouseEvent(timestamp, local, global, modifiers, source);
 }
 
 // Handlers for plain xcb events. Used only when XI 2.2 or newer is not available.
@@ -2339,7 +2374,7 @@ static inline int fixed1616ToInt(FP1616 val)
 }
 
 // With XI 2.2+ press/release/motion comes here instead of the above handlers.
-void QXcbWindow::handleXIMouseEvent(xcb_ge_event_t *event)
+void QXcbWindow::handleXIMouseEvent(xcb_ge_event_t *event, Qt::MouseEventSource source)
 {
     QXcbConnection *conn = connection();
     xXIDeviceEvent *ev = reinterpret_cast<xXIDeviceEvent *>(event);
@@ -2359,20 +2394,27 @@ void QXcbWindow::handleXIMouseEvent(xcb_ge_event_t *event)
             conn->setButton(conn->translateMouseButton(i), XIMaskIsSet(buttonMask, i));
     }
 
+    const char *sourceName = nullptr;
+    if (lcQpaXInput().isDebugEnabled()) {
+        const QMetaObject *metaObject = qt_getEnumMetaObject(source);
+        const QMetaEnum me = metaObject->enumerator(metaObject->indexOfEnumerator(qt_getEnumName(source)));
+        sourceName = me.valueToKey(source);
+    }
+
     switch (ev->evtype) {
     case XI_ButtonPress:
-        qCDebug(lcQpaXInput, "XI2 mouse press, button %d, time %d", button, ev->time);
+        qCDebug(lcQpaXInput, "XI2 mouse press, button %d, time %d, source %s", button, ev->time, sourceName);
         conn->setButton(button, true);
-        handleButtonPressEvent(event_x, event_y, root_x, root_y, ev->detail, modifiers, ev->time);
+        handleButtonPressEvent(event_x, event_y, root_x, root_y, ev->detail, modifiers, ev->time, source);
         break;
     case XI_ButtonRelease:
-        qCDebug(lcQpaXInput, "XI2 mouse release, button %d, time %d", button, ev->time);
+        qCDebug(lcQpaXInput, "XI2 mouse release, button %d, time %d, source %s", button, ev->time, sourceName);
         conn->setButton(button, false);
-        handleButtonReleaseEvent(event_x, event_y, root_x, root_y, ev->detail, modifiers, ev->time);
+        handleButtonReleaseEvent(event_x, event_y, root_x, root_y, ev->detail, modifiers, ev->time, source);
         break;
     case XI_Motion:
-        qCDebug(lcQpaXInput, "XI2 mouse motion %d,%d, time %d", event_x, event_y, ev->time);
-        handleMotionNotifyEvent(event_x, event_y, root_x, root_y, modifiers, ev->time);
+        qCDebug(lcQpaXInput, "XI2 mouse motion %d,%d, time %d, source %s", event_x, event_y, ev->time, sourceName);
+        handleMotionNotifyEvent(event_x, event_y, root_x, root_y, modifiers, ev->time, source);
         break;
     default:
         qWarning() << "Unrecognized XI2 mouse event" << ev->evtype;
@@ -2415,10 +2457,11 @@ void QXcbWindow::handleXIEnterLeave(xcb_ge_event_t *event)
 
 QXcbWindow *QXcbWindow::toWindow() { return this; }
 
-void QXcbWindow::handleMouseEvent(xcb_timestamp_t time, const QPoint &local, const QPoint &global, Qt::KeyboardModifiers modifiers)
+void QXcbWindow::handleMouseEvent(xcb_timestamp_t time, const QPoint &local, const QPoint &global,
+        Qt::KeyboardModifiers modifiers, Qt::MouseEventSource source)
 {
     connection()->setTime(time);
-    QWindowSystemInterface::handleMouseEvent(window(), time, local, global, connection()->buttons(), modifiers);
+    QWindowSystemInterface::handleMouseEvent(window(), time, local, global, connection()->buttons(), modifiers, source);
 }
 
 void QXcbWindow::handleEnterNotifyEvent(const xcb_enter_notify_event_t *event)
@@ -2612,6 +2655,7 @@ bool QXcbWindow::startSystemResize(const QPoint &pos, Qt::Corner corner)
     xcb_client_message_event_t xev;
     xev.response_type = XCB_CLIENT_MESSAGE;
     xev.type = moveResize;
+    xev.sequence = 0;
     xev.window = xcb_window();
     xev.format = 32;
     const QPoint globalPos = window()->mapToGlobal(pos);
@@ -2640,6 +2684,7 @@ void QXcbWindow::sendXEmbedMessage(xcb_window_t window, quint32 message,
 
     event.response_type = XCB_CLIENT_MESSAGE;
     event.format = 32;
+    event.sequence = 0;
     event.window = window;
     event.type = atom(QXcbAtom::_XEMBED);
     event.data.data32[0] = connection()->time();
diff --git a/src/plugins/platforms/xcb/qxcbwindow.h b/src/plugins/platforms/xcb/qxcbwindow.h
index 72688cdf168..7b70dc2ef83 100644
--- a/src/plugins/platforms/xcb/qxcbwindow.h
+++ b/src/plugins/platforms/xcb/qxcbwindow.h
@@ -139,13 +139,14 @@ public:
     void handleFocusOutEvent(const xcb_focus_out_event_t *event) Q_DECL_OVERRIDE;
     void handlePropertyNotifyEvent(const xcb_property_notify_event_t *event) Q_DECL_OVERRIDE;
 #ifdef XCB_USE_XINPUT22
-    void handleXIMouseEvent(xcb_ge_event_t *) Q_DECL_OVERRIDE;
+    void handleXIMouseEvent(xcb_ge_event_t *, Qt::MouseEventSource source = Qt::MouseEventNotSynthesized) Q_DECL_OVERRIDE;
     void handleXIEnterLeave(xcb_ge_event_t *) Q_DECL_OVERRIDE;
 #endif
 
     QXcbWindow *toWindow() Q_DECL_OVERRIDE;
 
-    void handleMouseEvent(xcb_timestamp_t time, const QPoint &local, const QPoint &global, Qt::KeyboardModifiers modifiers);
+    void handleMouseEvent(xcb_timestamp_t time, const QPoint &local, const QPoint &global,
+                          Qt::KeyboardModifiers modifiers, Qt::MouseEventSource source);
 
     void updateNetWmUserTime(xcb_timestamp_t timestamp);
 
@@ -214,13 +215,13 @@ protected:
     bool compressExposeEvent(QRegion &exposeRegion);
 
     void handleButtonPressEvent(int event_x, int event_y, int root_x, int root_y,
-                                int detail, Qt::KeyboardModifiers modifiers, xcb_timestamp_t timestamp);
+                                int detail, Qt::KeyboardModifiers modifiers, xcb_timestamp_t timestamp, Qt::MouseEventSource source = Qt::MouseEventNotSynthesized);
 
     void handleButtonReleaseEvent(int event_x, int event_y, int root_x, int root_y,
-                                  int detail, Qt::KeyboardModifiers modifiers, xcb_timestamp_t timestamp);
+                                  int detail, Qt::KeyboardModifiers modifiers, xcb_timestamp_t timestamp, Qt::MouseEventSource source = Qt::MouseEventNotSynthesized);
 
     void handleMotionNotifyEvent(int event_x, int event_y, int root_x, int root_y,
-                                 Qt::KeyboardModifiers modifiers, xcb_timestamp_t timestamp);
+                                 Qt::KeyboardModifiers modifiers, xcb_timestamp_t timestamp, Qt::MouseEventSource source = Qt::MouseEventNotSynthesized);
 
     void handleEnterNotifyEvent(int event_x, int event_y, int root_x, int root_y,
                                 quint8 mode, quint8 detail, xcb_timestamp_t timestamp);
diff --git a/src/plugins/platforms/xcb/qxcbwmsupport.cpp b/src/plugins/platforms/xcb/qxcbwmsupport.cpp
index 38116ac2399..470f021314a 100644
--- a/src/plugins/platforms/xcb/qxcbwmsupport.cpp
+++ b/src/plugins/platforms/xcb/qxcbwmsupport.cpp
@@ -122,10 +122,10 @@ void QXcbWMSupport::updateVirtualRoots()
     } while (remaining > 0);
 
 #ifdef Q_XCB_DEBUG
-    qDebug() << "======== updateVirtualRoots";
+    qDebug("======== updateVirtualRoots");
     for (int i = 0; i < net_virtual_roots.size(); ++i)
         qDebug() << connection()->atomName(net_virtual_roots.at(i));
-    qDebug() << "======== updateVirtualRoots";
+    qDebug("======== updateVirtualRoots");
 #endif
 }
 
diff --git a/src/plugins/platforms/xcb/xcb-plugin.pro b/src/plugins/platforms/xcb/xcb-plugin.pro
index 09ab1ad77a9..75684a769b3 100644
--- a/src/plugins/platforms/xcb/xcb-plugin.pro
+++ b/src/plugins/platforms/xcb/xcb-plugin.pro
@@ -1,13 +1,12 @@
 TARGET = qxcb
 
-PLUGIN_TYPE = platforms
-PLUGIN_CLASS_NAME = QXcbIntegrationPlugin
-!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
-load(qt_plugin)
-
 QT += core-private gui-private platformsupport-private xcb_qpa_lib-private
 
 SOURCES = \
     qxcbmain.cpp
 OTHER_FILES += xcb.json README
 
+PLUGIN_TYPE = platforms
+PLUGIN_CLASS_NAME = QXcbIntegrationPlugin
+!equals(TARGET, $$QT_DEFAULT_QPA_PLUGIN): PLUGIN_EXTENDS = -
+load(qt_plugin)
diff --git a/src/plugins/platforms/xcb/xcb_qpa_lib.pro b/src/plugins/platforms/xcb/xcb_qpa_lib.pro
index 302d87e0079..f4a4e5a78a8 100644
--- a/src/plugins/platforms/xcb/xcb_qpa_lib.pro
+++ b/src/plugins/platforms/xcb/xcb_qpa_lib.pro
@@ -1,8 +1,6 @@
 TARGET     = QtXcbQpa
 CONFIG += no_module_headers internal_module
 
-load(qt_module)
-
 QT += core-private gui-private platformsupport-private
 
 SOURCES = \
@@ -105,3 +103,4 @@ contains(QT_CONFIG, xkbcommon-qt) {
     QMAKE_CXXFLAGS += $$QMAKE_CFLAGS_XKBCOMMON
 }
 
+load(qt_module)
diff --git a/src/plugins/printsupport/cocoa/cocoa.pro b/src/plugins/printsupport/cocoa/cocoa.pro
index c993b425742..242c596bcd0 100644
--- a/src/plugins/printsupport/cocoa/cocoa.pro
+++ b/src/plugins/printsupport/cocoa/cocoa.pro
@@ -1,8 +1,5 @@
 TARGET = cocoaprintersupport
 MODULE = cocoaprintersupport
-PLUGIN_TYPE = printsupport
-PLUGIN_CLASS_NAME = QCocoaPrinterSupportPlugin
-load(qt_plugin)
 
 QT += gui-private printsupport-private
 LIBS += -framework AppKit
@@ -10,3 +7,7 @@ LIBS += -framework AppKit
 SOURCES += main.cpp
 
 OTHER_FILES += cocoa.json
+
+PLUGIN_TYPE = printsupport
+PLUGIN_CLASS_NAME = QCocoaPrinterSupportPlugin
+load(qt_plugin)
diff --git a/src/plugins/printsupport/cups/cups.pro b/src/plugins/printsupport/cups/cups.pro
index cdbb08b10a5..757408e7f72 100644
--- a/src/plugins/printsupport/cups/cups.pro
+++ b/src/plugins/printsupport/cups/cups.pro
@@ -1,8 +1,5 @@
 TARGET = cupsprintersupport
 MODULE = cupsprintersupport
-PLUGIN_TYPE = printsupport
-PLUGIN_CLASS_NAME = QCupsPrinterSupportPlugin
-load(qt_plugin)
 
 QT += core-private gui-private printsupport printsupport-private
 
@@ -20,3 +17,7 @@ HEADERS += qcupsprintersupport_p.h \
     qcupsprintengine_p.h
 
 OTHER_FILES += cups.json
+
+PLUGIN_TYPE = printsupport
+PLUGIN_CLASS_NAME = QCupsPrinterSupportPlugin
+load(qt_plugin)
diff --git a/src/plugins/printsupport/windows/windows.pro b/src/plugins/printsupport/windows/windows.pro
index 3366262ef03..06694fb7fe6 100644
--- a/src/plugins/printsupport/windows/windows.pro
+++ b/src/plugins/printsupport/windows/windows.pro
@@ -1,8 +1,5 @@
 TARGET = windowsprintersupport
 MODULE = windowsprintersupport
-PLUGIN_TYPE = printsupport
-PLUGIN_CLASS_NAME = QWindowsPrinterSupportPlugin
-load(qt_plugin)
 
 QT *= core-private
 QT *= gui-private
@@ -22,3 +19,7 @@ HEADERS += \
 OTHER_FILES += windows.json
 
 LIBS += -lwinspool -lcomdlg32 -lgdi32 -luser32
+
+PLUGIN_TYPE = printsupport
+PLUGIN_CLASS_NAME = QWindowsPrinterSupportPlugin
+load(qt_plugin)
diff --git a/src/printsupport/kernel/qplatformprintdevice.cpp b/src/printsupport/kernel/qplatformprintdevice.cpp
index a725a4a7d6d..9ddef85bf9c 100644
--- a/src/printsupport/kernel/qplatformprintdevice.cpp
+++ b/src/printsupport/kernel/qplatformprintdevice.cpp
@@ -59,6 +59,9 @@ QPlatformPrintDevice::QPlatformPrintDevice()
       m_haveOutputBins(false),
       m_haveDuplexModes(false),
       m_haveColorModes(false)
+#ifndef QT_NO_MIMETYPES
+    , m_haveMimeTypes(false)
+#endif
 {
 }
 
@@ -74,6 +77,9 @@ QPlatformPrintDevice::QPlatformPrintDevice(const QString &id)
       m_haveOutputBins(false),
       m_haveDuplexModes(false),
       m_haveColorModes(false)
+#ifndef QT_NO_MIMETYPES
+    , m_haveMimeTypes(false)
+#endif
 {
 }
 
diff --git a/src/printsupport/kernel/qprintengine_win.cpp b/src/printsupport/kernel/qprintengine_win.cpp
index 387dfca9c6d..edf4dcb164d 100644
--- a/src/printsupport/kernel/qprintengine_win.cpp
+++ b/src/printsupport/kernel/qprintengine_win.cpp
@@ -169,7 +169,7 @@ bool QWin32PrintEngine::begin(QPaintDevice *pdev)
         cleanUp();
 
 #ifdef QT_DEBUG_METRICS
-    qDebug() << "QWin32PrintEngine::begin()";
+    qDebug("QWin32PrintEngine::begin()");
     d->debugMetrics();
 #endif // QT_DEBUG_METRICS
 
@@ -236,7 +236,7 @@ bool QWin32PrintEngine::newPage()
         SetBkMode(d->hdc, TRANSPARENT);
 
 #ifdef QT_DEBUG_METRICS
-    qDebug() << "QWin32PrintEngine::newPage()";
+    qDebug("QWin32PrintEngine::newPage()");
     d->debugMetrics();
 #endif // QT_DEBUG_METRICS
 
@@ -930,7 +930,7 @@ void QWin32PrintEnginePrivate::initialize()
     initHDC();
 
 #if defined QT_DEBUG_DRAW || defined QT_DEBUG_METRICS
-    qDebug() << "QWin32PrintEngine::initialize()";
+    qDebug("QWin32PrintEngine::initialize()");
     debugMetrics();
 #endif // QT_DEBUG_DRAW || QT_DEBUG_METRICS
 }
@@ -1007,7 +1007,7 @@ void QWin32PrintEnginePrivate::doReinit()
 bool QWin32PrintEnginePrivate::resetDC()
 {
     if (!hdc) {
-        qWarning() << "ResetDC() called with null hdc.";
+        qWarning("ResetDC() called with null hdc.");
         return false;
     }
     const HDC oldHdc = hdc;
@@ -1593,7 +1593,7 @@ void QWin32PrintEngine::setGlobalDevMode(HGLOBAL globalDevNames, HGLOBAL globalD
         d->initHDC();
 
 #if defined QT_DEBUG_DRAW || defined QT_DEBUG_METRICS
-    qDebug() << "QWin32PrintEngine::setGlobalDevMode()";
+    qDebug("QWin32PrintEngine::setGlobalDevMode()");
     debugMetrics();
 #endif // QT_DEBUG_DRAW || QT_DEBUG_METRICS
 }
diff --git a/src/printsupport/kernel/qprinter.cpp b/src/printsupport/kernel/qprinter.cpp
index cbab151ea0c..584be111991 100644
--- a/src/printsupport/kernel/qprinter.cpp
+++ b/src/printsupport/kernel/qprinter.cpp
@@ -2135,7 +2135,7 @@ int QPrinter::toPage() const
 void QPrinter::setFromTo(int from, int to)
 {
     if (from > to) {
-        qWarning() << "QPrinter::setFromTo: 'from' must be less than or equal to 'to'";
+        qWarning("QPrinter::setFromTo: 'from' must be less than or equal to 'to'");
         from = to;
     }
     d->fromPage = from;
diff --git a/src/printsupport/printsupport.pro b/src/printsupport/printsupport.pro
index 6dd3eaab3c0..52eab672d33 100644
--- a/src/printsupport/printsupport.pro
+++ b/src/printsupport/printsupport.pro
@@ -3,15 +3,14 @@ QT = core-private gui-private widgets-private
 
 DEFINES   += QT_NO_USING_NAMESPACE
 
-MODULE_PLUGIN_TYPES = \
-    printsupport
-
 QMAKE_DOCS = $$PWD/doc/qtprintsupport.qdocconf
 
-load(qt_module)
-
 QMAKE_LIBS += $$QMAKE_LIBS_PRINTSUPPORT
 
 include(kernel/kernel.pri)
 include(widgets/widgets.pri)
 include(dialogs/dialogs.pri)
+
+MODULE_PLUGIN_TYPES = \
+    printsupport
+load(qt_module)
diff --git a/src/sql/drivers/ibase/qsql_ibase.cpp b/src/sql/drivers/ibase/qsql_ibase.cpp
index ae48fdb90a7..6fd91b6b766 100644
--- a/src/sql/drivers/ibase/qsql_ibase.cpp
+++ b/src/sql/drivers/ibase/qsql_ibase.cpp
@@ -1297,7 +1297,7 @@ int QIBaseResult::size()
             if (ct == isc_info_req_select_count)
                 return val;
         }
-        //qDebug() << "size -1";
+        //qDebug("size -1");
         return -1;
 
         unsigned int i, result_size;
diff --git a/src/sql/drivers/odbc/qsql_odbc.cpp b/src/sql/drivers/odbc/qsql_odbc.cpp
index 139b2a8f2b9..59ef42d609b 100644
--- a/src/sql/drivers/odbc/qsql_odbc.cpp
+++ b/src/sql/drivers/odbc/qsql_odbc.cpp
@@ -1931,11 +1931,14 @@ bool QODBCDriver::open(const QString & db,
     if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {
         qSqlWarning(QLatin1String("QODBCDriver::open: Unable to allocate connection"), d);
         setOpenError(true);
+        cleanup();
         return false;
     }
 
-    if (!d->setConnectionOptions(connOpts))
+    if (!d->setConnectionOptions(connOpts)) {
+        cleanup();
         return false;
+    }
 
     // Create the connection string
     QString connQStr;
@@ -1968,6 +1971,7 @@ bool QODBCDriver::open(const QString & db,
     if (r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) {
         setLastError(qMakeError(tr("Unable to connect"), QSqlError::ConnectionError, d));
         setOpenError(true);
+        cleanup();
         return false;
     }
 
@@ -1975,6 +1979,7 @@ bool QODBCDriver::open(const QString & db,
         setLastError(qMakeError(tr("Unable to connect - Driver doesn't support all "
                      "functionality required"), QSqlError::ConnectionError, d));
         setOpenError(true);
+        cleanup();
         return false;
     }
 
@@ -2195,7 +2200,7 @@ void QODBCDriverPrivate::checkHasSQLFetchScroll()
     SQLRETURN r = SQLGetFunctions(hDbc, SQL_API_SQLFETCHSCROLL, &sup);
     if ((r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO) || sup != SQL_TRUE) {
         hasSQLFetchScroll = false;
-        qWarning() << "QODBCDriver::checkHasSQLFetchScroll: Warning - Driver doesn't support scrollable result sets, use forward only mode for queries";
+        qWarning("QODBCDriver::checkHasSQLFetchScroll: Warning - Driver doesn't support scrollable result sets, use forward only mode for queries");
     }
 }
 
@@ -2244,7 +2249,7 @@ bool QODBCDriver::beginTransaction()
 {
     Q_D(QODBCDriver);
     if (!isOpen()) {
-        qWarning() << "QODBCDriver::beginTransaction: Database not open";
+        qWarning("QODBCDriver::beginTransaction: Database not open");
         return false;
     }
     SQLUINTEGER ac(SQL_AUTOCOMMIT_OFF);
@@ -2264,7 +2269,7 @@ bool QODBCDriver::commitTransaction()
 {
     Q_D(QODBCDriver);
     if (!isOpen()) {
-        qWarning() << "QODBCDriver::commitTransaction: Database not open";
+        qWarning("QODBCDriver::commitTransaction: Database not open");
         return false;
     }
     SQLRETURN r = SQLEndTran(SQL_HANDLE_DBC,
@@ -2282,7 +2287,7 @@ bool QODBCDriver::rollbackTransaction()
 {
     Q_D(QODBCDriver);
     if (!isOpen()) {
-        qWarning() << "QODBCDriver::rollbackTransaction: Database not open";
+        qWarning("QODBCDriver::rollbackTransaction: Database not open");
         return false;
     }
     SQLRETURN r = SQLEndTran(SQL_HANDLE_DBC,
diff --git a/src/sql/drivers/psql/qsql_psql.cpp b/src/sql/drivers/psql/qsql_psql.cpp
index b75c9ee29c7..fcf75af298f 100644
--- a/src/sql/drivers/psql/qsql_psql.cpp
+++ b/src/sql/drivers/psql/qsql_psql.cpp
@@ -1421,8 +1421,10 @@ bool QPSQLDriver::subscribeToNotification(const QString &name)
         PGresult *result = d->exec(query);
         if (PQresultStatus(result) != PGRES_COMMAND_OK) {
             setLastError(qMakeError(tr("Unable to subscribe"), QSqlError::StatementError, d, result));
+            PQclear(result);
             return false;
         }
+        PQclear(result);
 
         if (!d->sn) {
             d->sn = new QSocketNotifier(socket, QSocketNotifier::Read);
@@ -1454,8 +1456,10 @@ bool QPSQLDriver::unsubscribeFromNotification(const QString &name)
     PGresult *result = d->exec(query);
     if (PQresultStatus(result) != PGRES_COMMAND_OK) {
         setLastError(qMakeError(tr("Unable to unsubscribe"), QSqlError::StatementError, d, result));
+        PQclear(result);
         return false;
     }
+    PQclear(result);
 
     d->seid.removeAll(name);
 
diff --git a/src/sql/drivers/sqlite2/qsql_sqlite2.cpp b/src/sql/drivers/sqlite2/qsql_sqlite2.cpp
index 46b0a356d37..67c24e41680 100644
--- a/src/sql/drivers/sqlite2/qsql_sqlite2.cpp
+++ b/src/sql/drivers/sqlite2/qsql_sqlite2.cpp
@@ -144,8 +144,6 @@ public:
     QVector<QVariant> firstRow;
 };
 
-static const uint initial_cache_size = 128;
-
 QSQLite2ResultPrivate::QSQLite2ResultPrivate(QSQLite2Result *q, const QSQLite2Driver *drv)
     : QSqlCachedResultPrivate(q, drv),
       currentTail(0),
diff --git a/src/sql/kernel/qsqlresult.h b/src/sql/kernel/qsqlresult.h
index ad5f615a527..c6611c925ff 100644
--- a/src/sql/kernel/qsqlresult.h
+++ b/src/sql/kernel/qsqlresult.h
@@ -44,6 +44,9 @@
 #include <QtCore/qvector.h>
 #include <QtSql/qsql.h>
 
+// for testing:
+class tst_QSqlQuery;
+
 QT_BEGIN_NAMESPACE
 
 
@@ -60,6 +63,8 @@ class Q_SQL_EXPORT QSqlResult
     Q_DECLARE_PRIVATE(QSqlResult)
     friend class QSqlQuery;
     friend class QSqlTableModelPrivate;
+    // for testing:
+    friend class ::tst_QSqlQuery;
 
 public:
     virtual ~QSqlResult();
diff --git a/src/sql/sql.pro b/src/sql/sql.pro
index 10004cb445d..218671d7e72 100644
--- a/src/sql/sql.pro
+++ b/src/sql/sql.pro
@@ -4,13 +4,8 @@ QT         = core-private
 DEFINES += QT_NO_USING_NAMESPACE
 win32-msvc*|win32-icc:QMAKE_LFLAGS += /BASE:0x62000000
 
-MODULE_PLUGIN_TYPES = \
-    sqldrivers
-
 QMAKE_DOCS = $$PWD/doc/qtsql.qdocconf
 
-load(qt_module)
-
 DEFINES += QT_NO_CAST_FROM_ASCII
 PRECOMPILED_HEADER = ../corelib/global/qt_pch.h
 SQL_P = sql
@@ -18,3 +13,7 @@ SQL_P = sql
 include(kernel/kernel.pri)
 include(drivers/drivers.pri)
 include(models/models.pri)
+
+MODULE_PLUGIN_TYPES = \
+    sqldrivers
+load(qt_module)
diff --git a/src/testlib/Qt5TestConfigExtras.cmake.in b/src/testlib/Qt5TestConfigExtras.cmake.in
new file mode 100644
index 00000000000..2a575958ae4
--- /dev/null
+++ b/src/testlib/Qt5TestConfigExtras.cmake.in
@@ -0,0 +1,5 @@
+
+set_property(TARGET Qt5::Test
+  APPEND PROPERTY
+    INTERFACE_COMPILE_DEFINITIONS QT_TESTCASE_BUILDDIR=\\\"\${CMAKE_BINARY_DIR}\\\"
+)
diff --git a/src/testlib/qtest_gui.h b/src/testlib/qtest_gui.h
index fd09c1202fb..2faf37f32b6 100644
--- a/src/testlib/qtest_gui.h
+++ b/src/testlib/qtest_gui.h
@@ -55,6 +55,7 @@
 #include <QtTest/qtesttouch.h>
 #include <QtTest/qtestkeyboard.h>
 
+#include <QtGui/qcolor.h>
 #include <QtGui/qpixmap.h>
 #include <QtGui/qimage.h>
 
@@ -73,6 +74,11 @@ QT_BEGIN_NAMESPACE
 namespace QTest
 {
 
+template<> inline char *toString(const QColor &color)
+{
+    return qstrdup(color.name().toLocal8Bit().constData());
+}
+
 inline bool qCompare(QIcon const &t1, QIcon const &t2, const char *actual, const char *expected,
                     const char *file, int line)
 {
diff --git a/src/testlib/qtestspontaneevent.h b/src/testlib/qtestspontaneevent.h
index f8982325ec1..ae10fabd31a 100644
--- a/src/testlib/qtestspontaneevent.h
+++ b/src/testlib/qtestspontaneevent.h
@@ -82,17 +82,10 @@ public:
     }
 #endif
 
+    // ### Qt 6: remove everything except this function:
     static inline void setSpontaneous(QEvent *ev)
     {
-        // use a union instead of a reinterpret_cast to prevent alignment warnings
-        union
-        {
-            QSpontaneKeyEvent *skePtr;
-            QEvent *evPtr;
-        } helper;
-
-        helper.evPtr = ev;
-        helper.skePtr->setSpontaneous();
+        ev->setSpontaneous();
     }
 
 protected:
diff --git a/src/tools/bootstrap-dbus/bootstrap-dbus.pro b/src/tools/bootstrap-dbus/bootstrap-dbus.pro
index 4c466ba0e94..3b28c233114 100644
--- a/src/tools/bootstrap-dbus/bootstrap-dbus.pro
+++ b/src/tools/bootstrap-dbus/bootstrap-dbus.pro
@@ -9,8 +9,6 @@ DEFINES += \
 
 MODULE_INCNAME = QtDBus
 
-load(qt_module)
-
 QMAKE_CXXFLAGS += $$QT_HOST_CFLAGS_DBUS
 
 SOURCES = \
@@ -25,5 +23,7 @@ SOURCES = \
     ../../dbus/qdbus_symbols.cpp \
     ../../dbus/qdbusunixfiledescriptor.cpp
 
+load(qt_module)
+
 lib.CONFIG = dummy_install
 INSTALLS = lib
diff --git a/src/tools/bootstrap/bootstrap.pro b/src/tools/bootstrap/bootstrap.pro
index a412689ddf5..47aa8865683 100644
--- a/src/tools/bootstrap/bootstrap.pro
+++ b/src/tools/bootstrap/bootstrap.pro
@@ -27,11 +27,6 @@ DEFINES += \
 
 DEFINES -= QT_EVAL
 
-load(qt_module)
-
-# otherwise mingw headers do not declare common functions like putenv
-mingw: CONFIG -= strict_c++
-
 SOURCES += \
            ../../corelib/codecs/qlatincodec.cpp \
            ../../corelib/codecs/qtextcodec.cpp \
@@ -143,5 +138,10 @@ else:include(../../3rdparty/zlib_dependency.pri)
 
 win32:LIBS += -luser32 -lole32 -ladvapi32 -lshell32
 
+load(qt_module)
+
+# otherwise mingw headers do not declare common functions like putenv
+mingw: CONFIG -= strict_c++
+
 lib.CONFIG = dummy_install
 INSTALLS += lib
diff --git a/src/tools/uic/cpp/cppwriteinitialization.cpp b/src/tools/uic/cpp/cppwriteinitialization.cpp
index ebb7f8691ab..8c8141f9e51 100644
--- a/src/tools/uic/cpp/cppwriteinitialization.cpp
+++ b/src/tools/uic/cpp/cppwriteinitialization.cpp
@@ -1262,7 +1262,10 @@ void WriteInitialization::writeProperties(const QString &varName,
         } else {
             setFunction = QLatin1String("->setProperty(\"");
             setFunction += propertyName;
-            setFunction += QLatin1String("\", QVariant(");
+            setFunction += QLatin1String("\", QVariant");
+            if (p->kind() == DomProperty::Enum)
+                setFunction += QLatin1String("::fromValue");
+            setFunction += QLatin1Char('(');
         }
 
         QString varNewName = varName;
diff --git a/src/widgets/accessible/qaccessiblewidgetfactory.cpp b/src/widgets/accessible/qaccessiblewidgetfactory.cpp
index d0627f31a75..3bfef49965e 100644
--- a/src/widgets/accessible/qaccessiblewidgetfactory.cpp
+++ b/src/widgets/accessible/qaccessiblewidgetfactory.cpp
@@ -39,6 +39,7 @@
 
 #include "qaccessiblewidgets_p.h"
 #include "qaccessiblemenu_p.h"
+#include "private/qwidget_p.h"
 #include "simplewidgets_p.h"
 #include "rangecontrols_p.h"
 #include "complexwidgets_p.h"
@@ -59,7 +60,15 @@ QAccessibleInterface *qAccessibleFactory(const QString &classname, QObject *obje
     QAccessibleInterface *iface = 0;
     if (!object || !object->isWidgetType())
         return iface;
+
     QWidget *widget = static_cast<QWidget*>(object);
+    // QWidget emits destroyed() from its destructor instead of letting the QObject
+    // destructor do it, which means the QWidget is unregistered from the accessibillity
+    // cache. But QWidget destruction also emits enter and leave events, which may end
+    // up here, so we have to ensure that we don't fill the cache with an entry of
+    // a widget that is going away.
+    if (QWidgetPrivate::get(widget)->data.in_destructor)
+        return iface;
 
     if (false) {
 #ifndef QT_NO_LINEEDIT
diff --git a/src/widgets/accessible/widgets.pro b/src/widgets/accessible/widgets.pro
index c6af6d3f716..da8607c6378 100644
--- a/src/widgets/accessible/widgets.pro
+++ b/src/widgets/accessible/widgets.pro
@@ -1,10 +1,5 @@
 TARGET  = qtaccessiblewidgets
 
-PLUGIN_TYPE = accessible
-PLUGIN_EXTENDS = widgets
-PLUGIN_CLASS_NAME = AccessibleFactory
-load(qt_plugin)
-
 QT += core-private gui-private widgets-private
 
 QTDIR_build:REQUIRES += "contains(QT_CONFIG, accessibility)"
@@ -24,4 +19,7 @@ HEADERS  += qaccessiblewidgets.h \
             qaccessiblemenu.h \
             itemviews.h
 
-
+PLUGIN_TYPE = accessible
+PLUGIN_EXTENDS = widgets
+PLUGIN_CLASS_NAME = AccessibleFactory
+load(qt_plugin)
diff --git a/src/widgets/dialogs/qcolordialog.cpp b/src/widgets/dialogs/qcolordialog.cpp
index beeef75fb5c..ad13deb0440 100644
--- a/src/widgets/dialogs/qcolordialog.cpp
+++ b/src/widgets/dialogs/qcolordialog.cpp
@@ -196,7 +196,6 @@ public:
     QSize sizeHint() const Q_DECL_OVERRIDE;
 
     virtual void setCellBrush(int row, int col, const QBrush &);
-    QBrush cellBrush(int row, int col);
 
     inline int cellWidth() const
         { return cellw; }
@@ -465,20 +464,6 @@ void QWellArray::setCellBrush(int row, int col, const QBrush &b)
         d->brush[row*numCols()+col] = b;
 }
 
-/*
-  Returns the brush set for the cell at \a row, \a column. If no brush is
-  set, Qt::NoBrush is returned.
-*/
-
-QBrush QWellArray::cellBrush(int row, int col)
-{
-    if (d && row >= 0 && row < numRows() && col >= 0 && col < numCols())
-        return d->brush[row*numCols()+col];
-    return Qt::NoBrush;
-}
-
-
-
 /*!\reimp
 */
 
diff --git a/src/widgets/dialogs/qerrormessage.cpp b/src/widgets/dialogs/qerrormessage.cpp
index c5e764236a0..77d9eb29acf 100644
--- a/src/widgets/dialogs/qerrormessage.cpp
+++ b/src/widgets/dialogs/qerrormessage.cpp
@@ -402,4 +402,6 @@ void QErrorMessagePrivate::retranslateStrings()
 
 QT_END_NAMESPACE
 
+#include "moc_qerrormessage.cpp"
+
 #endif // QT_NO_ERRORMESSAGE
diff --git a/src/widgets/dialogs/qfileinfogatherer.cpp b/src/widgets/dialogs/qfileinfogatherer.cpp
index b20db8fc7c4..014792ea936 100644
--- a/src/widgets/dialogs/qfileinfogatherer.cpp
+++ b/src/widgets/dialogs/qfileinfogatherer.cpp
@@ -345,3 +345,5 @@ void QFileInfoGatherer::fetch(const QFileInfo &fileInfo, QElapsedTimer &base, bo
 #endif // QT_NO_FILESYSTEMMODEL
 
 QT_END_NAMESPACE
+
+#include "moc_qfileinfogatherer_p.cpp"
diff --git a/src/widgets/dialogs/qsidebar.cpp b/src/widgets/dialogs/qsidebar.cpp
index 1b1eb6472ef..d86cddab610 100644
--- a/src/widgets/dialogs/qsidebar.cpp
+++ b/src/widgets/dialogs/qsidebar.cpp
@@ -515,4 +515,6 @@ bool QSidebar::event(QEvent * event)
 
 QT_END_NAMESPACE
 
+#include "moc_qsidebar_p.cpp"
+
 #endif
diff --git a/src/widgets/dialogs/qwizard_win.cpp b/src/widgets/dialogs/qwizard_win.cpp
index 93381ce7b0f..8bc5ba7f567 100644
--- a/src/widgets/dialogs/qwizard_win.cpp
+++ b/src/widgets/dialogs/qwizard_win.cpp
@@ -53,18 +53,6 @@
 #include <QtGui/QWindow>
 #include <QtWidgets/QDesktopWidget>
 
-// Note, these tests are duplicates in qwindowsxpstyle_p.h.
-#ifdef Q_CC_GNU
-#  include <w32api.h>
-#  if (__W32API_MAJOR_VERSION >= 3 || (__W32API_MAJOR_VERSION == 2 && __W32API_MINOR_VERSION >= 5))
-#    ifdef _WIN32_WINNT
-#      undef _WIN32_WINNT
-#    endif
-#    define _WIN32_WINNT 0x0501
-#    include <commctrl.h>
-#  endif
-#endif
-
 #include <uxtheme.h>
 
 Q_DECLARE_METATYPE(QMargins)
diff --git a/src/widgets/effects/qgraphicseffect.cpp b/src/widgets/effects/qgraphicseffect.cpp
index abeb153e531..4d1d1e98965 100644
--- a/src/widgets/effects/qgraphicseffect.cpp
+++ b/src/widgets/effects/qgraphicseffect.cpp
@@ -1235,4 +1235,7 @@ void QGraphicsOpacityEffect::draw(QPainter *painter)
 
 QT_END_NAMESPACE
 
+#include "moc_qgraphicseffect.cpp"
+#include "moc_qgraphicseffect_p.cpp"
+
 #endif //QT_NO_GRAPHICSEFFECT
diff --git a/src/widgets/effects/qpixmapfilter.cpp b/src/widgets/effects/qpixmapfilter.cpp
index 1d4014cbae4..1ff4f8e88ad 100644
--- a/src/widgets/effects/qpixmapfilter.cpp
+++ b/src/widgets/effects/qpixmapfilter.cpp
@@ -1345,4 +1345,6 @@ void QPixmapDropShadowFilter::draw(QPainter *p,
 
 QT_END_NAMESPACE
 
+#include "moc_qpixmapfilter_p.cpp"
+
 #endif //QT_NO_GRAPHICSEFFECT
diff --git a/src/widgets/graphicsview/qgraphicsanchorlayout.cpp b/src/widgets/graphicsview/qgraphicsanchorlayout.cpp
index f20203cd804..176ce694a04 100644
--- a/src/widgets/graphicsview/qgraphicsanchorlayout.cpp
+++ b/src/widgets/graphicsview/qgraphicsanchorlayout.cpp
@@ -529,4 +529,7 @@ QSizeF QGraphicsAnchorLayout::sizeHint(Qt::SizeHint which, const QSizeF &constra
 }
 
 QT_END_NAMESPACE
+
+#include "moc_qgraphicsanchorlayout.cpp"
+
 #endif //QT_NO_GRAPHICSVIEW
diff --git a/src/widgets/graphicsview/qgraphicsitemanimation.cpp b/src/widgets/graphicsview/qgraphicsitemanimation.cpp
index 5e12e67a86b..c5687ee9b37 100644
--- a/src/widgets/graphicsview/qgraphicsitemanimation.cpp
+++ b/src/widgets/graphicsview/qgraphicsitemanimation.cpp
@@ -594,4 +594,6 @@ void QGraphicsItemAnimation::afterAnimationStep(qreal step)
 
 QT_END_NAMESPACE
 
+#include "moc_qgraphicsitemanimation.cpp"
+
 #endif // QT_NO_GRAPHICSVIEW
diff --git a/src/widgets/graphicsview/qgraphicsscenelinearindex.cpp b/src/widgets/graphicsview/qgraphicsscenelinearindex.cpp
index bd09570c4a0..06f91256129 100644
--- a/src/widgets/graphicsview/qgraphicsscenelinearindex.cpp
+++ b/src/widgets/graphicsview/qgraphicsscenelinearindex.cpp
@@ -91,3 +91,4 @@
     Add the \a item from the index.
 */
 
+#include "moc_qgraphicsscenelinearindex_p.cpp"
diff --git a/src/widgets/graphicsview/qgraphicswidget.cpp b/src/widgets/graphicsview/qgraphicswidget.cpp
index e7fca555501..d52aff51315 100644
--- a/src/widgets/graphicsview/qgraphicswidget.cpp
+++ b/src/widgets/graphicsview/qgraphicswidget.cpp
@@ -2417,4 +2417,6 @@ void QGraphicsWidget::dumpFocusChain()
 
 QT_END_NAMESPACE
 
+#include "moc_qgraphicswidget.cpp"
+
 #endif //QT_NO_GRAPHICSVIEW
diff --git a/src/widgets/itemviews/qabstractitemview.cpp b/src/widgets/itemviews/qabstractitemview.cpp
index 9135d1a23ca..da4492a6843 100644
--- a/src/widgets/itemviews/qabstractitemview.cpp
+++ b/src/widgets/itemviews/qabstractitemview.cpp
@@ -4401,7 +4401,20 @@ QPixmap QAbstractItemViewPrivate::renderToPixmap(const QModelIndexList &indexes,
     QItemViewPaintPairs paintPairs = draggablePaintPairs(indexes, r);
     if (paintPairs.isEmpty())
         return QPixmap();
-    QPixmap pixmap(r->size());
+
+    qreal scale = 1.0f;
+
+    Q_Q(const QAbstractItemView);
+    QWidget *window = q->window();
+    if (window) {
+        QWindow *windowHandle = window->windowHandle();
+        if (windowHandle)
+            scale = windowHandle->devicePixelRatio();
+    }
+
+    QPixmap pixmap(r->size() * scale);
+    pixmap.setDevicePixelRatio(scale);
+
     pixmap.fill(Qt::transparent);
     QPainter painter(&pixmap);
     QStyleOptionViewItem option = viewOptionsV1();
diff --git a/src/widgets/itemviews/qcolumnviewgrip.cpp b/src/widgets/itemviews/qcolumnviewgrip.cpp
index d2d1819cf7b..f7d6e6d2b04 100644
--- a/src/widgets/itemviews/qcolumnviewgrip.cpp
+++ b/src/widgets/itemviews/qcolumnviewgrip.cpp
@@ -189,4 +189,6 @@ originalXLocation(-1)
 
 QT_END_NAMESPACE
 
+#include "moc_qcolumnviewgrip_p.cpp"
+
 #endif // QT_NO_QCOLUMNVIEW
diff --git a/src/widgets/itemviews/qitemeditorfactory.cpp b/src/widgets/itemviews/qitemeditorfactory.cpp
index 9b7de87e325..5356ce3ad01 100644
--- a/src/widgets/itemviews/qitemeditorfactory.cpp
+++ b/src/widgets/itemviews/qitemeditorfactory.cpp
@@ -613,4 +613,6 @@ QT_END_NAMESPACE
 #include "qitemeditorfactory.moc"
 #endif
 
+#include "moc_qitemeditorfactory_p.cpp"
+
 #endif // QT_NO_ITEMVIEWS
diff --git a/src/widgets/itemviews/qlistview.cpp b/src/widgets/itemviews/qlistview.cpp
index 646ab58e3d6..3303aac6edc 100644
--- a/src/widgets/itemviews/qlistview.cpp
+++ b/src/widgets/itemviews/qlistview.cpp
@@ -822,7 +822,7 @@ void QListView::wheelEvent(QWheelEvent *e)
             QPoint pixelDelta(e->pixelDelta().y(), e->pixelDelta().x());
             QPoint angleDelta(e->angleDelta().y(), e->angleDelta().x());
             QWheelEvent hwe(e->pos(), e->globalPos(), pixelDelta, angleDelta, e->delta(),
-                            Qt::Horizontal, e->buttons(), e->modifiers(), e->phase());
+                            Qt::Horizontal, e->buttons(), e->modifiers(), e->phase(), e->source(), e->inverted());
             if (e->spontaneous())
                 qt_sendSpontaneousEvent(d->hbar, &hwe);
             else
@@ -1989,6 +1989,11 @@ int QCommonListViewBase::horizontalScrollToValue(const int /*index*/, QListView:
 /*
  * ListMode ListView Implementation
 */
+QListModeViewBase::QListModeViewBase(QListView *q, QListViewPrivate *d)
+    : QCommonListViewBase(q, d)
+{
+    dd->defaultDropAction = Qt::CopyAction;
+}
 
 #ifndef QT_NO_DRAGANDDROP
 QAbstractItemView::DropIndicatorPosition QListModeViewBase::position(const QPoint &pos, const QRect &rect, const QModelIndex &index) const
@@ -2755,7 +2760,7 @@ bool QIconModeViewBase::filterStartDrag(Qt::DropActions supportedActions)
         drag->setMimeData(dd->model->mimeData(indexes));
         drag->setPixmap(pixmap);
         drag->setHotSpot(dd->pressedPosition - rect.topLeft());
-        Qt::DropAction action = drag->exec(supportedActions, Qt::CopyAction);
+        Qt::DropAction action = drag->exec(supportedActions, dd->defaultDropAction);
         draggedItems.clear();
         if (action == Qt::MoveAction)
             dd->clearOrRemove();
@@ -3296,4 +3301,6 @@ QSize QListView::viewportSizeHint() const
 
 QT_END_NAMESPACE
 
+#include "moc_qlistview.cpp"
+
 #endif // QT_NO_LISTVIEW
diff --git a/src/widgets/itemviews/qlistview_p.h b/src/widgets/itemviews/qlistview_p.h
index 2e6f69713f8..90fb9e1407d 100644
--- a/src/widgets/itemviews/qlistview_p.h
+++ b/src/widgets/itemviews/qlistview_p.h
@@ -196,7 +196,7 @@ public:
 class QListModeViewBase : public QCommonListViewBase
 {
 public:
-    QListModeViewBase(QListView *q, QListViewPrivate *d) : QCommonListViewBase(q, d) {}
+    QListModeViewBase(QListView *q, QListViewPrivate *d);
 
     QVector<int> flowPositions;
     QVector<int> segmentPositions;
diff --git a/src/widgets/itemviews/qlistwidget.cpp b/src/widgets/itemviews/qlistwidget.cpp
index 434e819d9cc..9b34e89ef03 100644
--- a/src/widgets/itemviews/qlistwidget.cpp
+++ b/src/widgets/itemviews/qlistwidget.cpp
@@ -1975,5 +1975,6 @@ bool QListWidget::event(QEvent *e)
 QT_END_NAMESPACE
 
 #include "moc_qlistwidget.cpp"
+#include "moc_qlistwidget_p.cpp"
 
 #endif // QT_NO_LISTWIDGET
diff --git a/src/widgets/itemviews/qtablewidget.cpp b/src/widgets/itemviews/qtablewidget.cpp
index 9c2db0e0e4d..ed83ef7b85b 100644
--- a/src/widgets/itemviews/qtablewidget.cpp
+++ b/src/widgets/itemviews/qtablewidget.cpp
@@ -2721,5 +2721,6 @@ void QTableWidget::dropEvent(QDropEvent *event) {
 QT_END_NAMESPACE
 
 #include "moc_qtablewidget.cpp"
+#include "moc_qtablewidget_p.cpp"
 
 #endif // QT_NO_TABLEWIDGET
diff --git a/src/widgets/itemviews/qtreewidget.cpp b/src/widgets/itemviews/qtreewidget.cpp
index 9e65879f321..74ca7d28270 100644
--- a/src/widgets/itemviews/qtreewidget.cpp
+++ b/src/widgets/itemviews/qtreewidget.cpp
@@ -3466,5 +3466,6 @@ bool QTreeWidget::event(QEvent *e)
 QT_END_NAMESPACE
 
 #include "moc_qtreewidget.cpp"
+#include "moc_qtreewidget_p.cpp"
 
 #endif // QT_NO_TREEWIDGET
diff --git a/src/widgets/kernel/qapplication.cpp b/src/widgets/kernel/qapplication.cpp
index 2d23bb61a2d..2e68c7888f3 100644
--- a/src/widgets/kernel/qapplication.cpp
+++ b/src/widgets/kernel/qapplication.cpp
@@ -424,7 +424,7 @@ QWidget *QApplicationPrivate::hidden_focus_widget = 0; // will get keyboard inpu
 QWidget *QApplicationPrivate::active_window = 0;        // toplevel with keyboard focus
 #ifndef QT_NO_WHEELEVENT
 int QApplicationPrivate::wheel_scroll_lines;   // number of lines to scroll
-QWidget *QApplicationPrivate::wheel_widget = Q_NULLPTR;
+QPointer<QWidget> QApplicationPrivate::wheel_widget;
 #endif
 bool qt_in_tab_key_event = false;
 int qt_antialiasing_threshold = -1;
@@ -569,13 +569,18 @@ QApplication::QApplication(int &argc, char **argv)
 QApplication::QApplication(int &argc, char **argv, int _internal)
 #endif
     : QGuiApplication(*new QApplicationPrivate(argc, argv, _internal))
-{ Q_D(QApplication); d->construct(); }
+{
+    Q_D(QApplication);
+    d->init();
+}
 
 /*!
     \internal
 */
-void QApplicationPrivate::construct()
+void QApplicationPrivate::init()
 {
+    QGuiApplicationPrivate::init();
+
     initResources();
 
     qt_is_gui_used = (application_type != QApplicationPrivate::Tty);
@@ -3319,9 +3324,32 @@ bool QApplication::notify(QObject *receiver, QEvent *e)
             const bool spontaneous = wheel->spontaneous();
             const Qt::ScrollPhase phase = wheel->phase();
 
-            if (phase == Qt::NoScrollPhase || phase == Qt::ScrollBegin
-                || (phase == Qt::ScrollUpdate && !QApplicationPrivate::wheel_widget)) {
+            // Ideally, we should lock on a widget when it starts receiving wheel
+            // events. This avoids other widgets to start receiving those events
+            // as the mouse cursor hovers them. However, given the way common
+            // wheeled mice work, there's no certain way of connecting different
+            // wheel events as a stream. This results in the NoScrollPhase case,
+            // where we just send the event from the original receiver and up its
+            // hierarchy until the event gets accepted.
+            //
+            // In the case of more evolved input devices, like Apple's trackpad or
+            // Magic Mouse, we receive the scroll phase information. This helps us
+            // connect wheel events as a stream and therefore makes it easier to
+            // lock on the widget onto which the scrolling was initiated.
+            //
+            // We assume that, when supported, the phase cycle follows the pattern:
+            //
+            //         ScrollBegin (ScrollUpdate* ScrollEnd)+
+            //
+            // This means that we can have scrolling sequences (starting with ScrollBegin)
+            // or partial sequences (after a ScrollEnd and starting with ScrollUpdate).
+            // If wheel_widget is null because it was deleted, we also take the same
+            // code path as an initial sequence.
+            if (phase == Qt::NoScrollPhase || phase == Qt::ScrollBegin || !QApplicationPrivate::wheel_widget) {
 
+                // A system-generated ScrollBegin event starts a new user scrolling
+                // sequence, so we reset wheel_widget in case no one accepts the event
+                // or if we didn't get (or missed) a ScrollEnd previously.
                 if (spontaneous && phase == Qt::ScrollBegin)
                     QApplicationPrivate::wheel_widget = Q_NULLPTR;
 
@@ -3331,7 +3359,7 @@ bool QApplication::notify(QObject *receiver, QEvent *e)
                     QApplicationPrivate::giveFocusAccordingToFocusPolicy(w, e, relpos);
 
                 QWheelEvent we(relpos, wheel->globalPos(), wheel->pixelDelta(), wheel->angleDelta(), wheel->delta(), wheel->orientation(), wheel->buttons(),
-                               wheel->modifiers(), phase, wheel->source());
+                               wheel->modifiers(), phase, wheel->source(), wheel->inverted());
                 bool eventAccepted;
                 while (w) {
                     we.spont = spontaneous && w == receiver;
@@ -3339,7 +3367,10 @@ bool QApplication::notify(QObject *receiver, QEvent *e)
                     res = d->notify_helper(w, &we);
                     eventAccepted = we.isAccepted();
                     if (res && eventAccepted) {
-                        if (spontaneous && phase != Qt::NoScrollPhase)
+                        // A new scrolling sequence or partial sequence starts and w has accepted
+                        // the event. Therefore, we can set wheel_widget, but only if it's not
+                        // the end of a sequence.
+                        if (spontaneous && (phase == Qt::ScrollBegin || phase == Qt::ScrollUpdate))
                             QApplicationPrivate::wheel_widget = w;
                         break;
                     }
@@ -3350,25 +3381,27 @@ bool QApplication::notify(QObject *receiver, QEvent *e)
                     w = w->parentWidget();
                 }
                 wheel->setAccepted(eventAccepted);
-            } else if (QApplicationPrivate::wheel_widget) {
-                if (!spontaneous) {
-                    // wheel_widget may forward the wheel event to a delegate widget,
-                    // either directly or indirectly (e.g. QAbstractScrollArea will
-                    // forward to its QScrollBars through viewportEvent()). In that
-                    // case, the event will not be spontaneous but synthesized, so
-                    // we can send it straigth to the receiver.
-                    d->notify_helper(w, wheel);
-                } else {
-                    const QPoint &relpos = QApplicationPrivate::wheel_widget->mapFromGlobal(wheel->globalPos());
-                    QWheelEvent we(relpos, wheel->globalPos(), wheel->pixelDelta(), wheel->angleDelta(), wheel->delta(), wheel->orientation(), wheel->buttons(),
-                                   wheel->modifiers(), wheel->phase(), wheel->source());
-                    we.spont = true;
-                    we.ignore();
-                    d->notify_helper(QApplicationPrivate::wheel_widget, &we);
-                    wheel->setAccepted(we.isAccepted());
-                    if (phase == Qt::ScrollEnd)
-                        QApplicationPrivate::wheel_widget = Q_NULLPTR;
-                }
+            } else if (!spontaneous) {
+                // wheel_widget may forward the wheel event to a delegate widget,
+                // either directly or indirectly (e.g. QAbstractScrollArea will
+                // forward to its QScrollBars through viewportEvent()). In that
+                // case, the event will not be spontaneous but synthesized, so
+                // we can send it straight to the receiver.
+                d->notify_helper(w, wheel);
+            } else {
+                // The phase is either ScrollUpdate or ScrollEnd, and wheel_widget
+                // is set. Since it accepted the wheel event previously, we continue
+                // sending those events until we get a ScrollEnd, which signifies
+                // the end of the natural scrolling sequence.
+                const QPoint &relpos = QApplicationPrivate::wheel_widget->mapFromGlobal(wheel->globalPos());
+                QWheelEvent we(relpos, wheel->globalPos(), wheel->pixelDelta(), wheel->angleDelta(), wheel->delta(), wheel->orientation(), wheel->buttons(),
+                               wheel->modifiers(), wheel->phase(), wheel->source());
+                we.spont = true;
+                we.ignore();
+                d->notify_helper(QApplicationPrivate::wheel_widget, &we);
+                wheel->setAccepted(we.isAccepted());
+                if (phase == Qt::ScrollEnd)
+                    QApplicationPrivate::wheel_widget = Q_NULLPTR;
             }
         }
         break;
@@ -3546,6 +3579,10 @@ bool QApplication::notify(QObject *receiver, QEvent *e)
             QApplicationPrivate::giveFocusAccordingToFocusPolicy(widget, e, localPos);
         }
 
+#ifndef QT_NO_GESTURES
+        QPointer<QWidget> gesturePendingWidget;
+#endif
+
         while (widget) {
             // first, try to deliver the touch event
             acceptTouchEvents = widget->testAttribute(Qt::WA_AcceptTouchEvents);
@@ -3563,14 +3600,16 @@ bool QApplication::notify(QObject *receiver, QEvent *e)
             touchEvent->spont = false;
             if (res && eventAccepted) {
                 // the first widget to accept the TouchBegin gets an implicit grab.
-                for (int i = 0; i < touchEvent->touchPoints().count(); ++i) {
-                    const QTouchEvent::TouchPoint &touchPoint = touchEvent->touchPoints().at(i);
-                    d->activeTouchPoints[QGuiApplicationPrivate::ActiveTouchPointsKey(touchEvent->device(), touchPoint.id())].target = widget;
-                }
-                break;
-            } else if (p.isNull() || widget->isWindow() || widget->testAttribute(Qt::WA_NoMousePropagation)) {
+                d->activateImplicitTouchGrab(widget, touchEvent);
                 break;
             }
+#ifndef QT_NO_GESTURES
+            if (gesturePendingWidget.isNull() && widget && QGestureManager::gesturePending(widget))
+                gesturePendingWidget = widget;
+#endif
+            if (p.isNull() || widget->isWindow() || widget->testAttribute(Qt::WA_NoMousePropagation))
+                break;
+
             QPoint offset = widget->pos();
             widget = widget->parentWidget();
             touchEvent->setTarget(widget);
@@ -3584,9 +3623,27 @@ bool QApplication::notify(QObject *receiver, QEvent *e)
             }
         }
 
+#ifndef QT_NO_GESTURES
+        if (!eventAccepted && !gesturePendingWidget.isNull()) {
+            // the first widget subscribed to a gesture gets an implicit grab
+            d->activateImplicitTouchGrab(gesturePendingWidget, touchEvent);
+        }
+#endif
+
         touchEvent->setAccepted(eventAccepted);
         break;
     }
+    case QEvent::TouchUpdate:
+    case QEvent::TouchEnd:
+    {
+        QWidget *widget = static_cast<QWidget *>(receiver);
+        // We may get here if the widget is subscribed to a gesture,
+        // but has not accepted TouchBegin. Propagate touch events
+        // only if TouchBegin has been accepted.
+        if (widget && widget->testAttribute(Qt::WA_WState_AcceptedTouchBeginEvent))
+            res = d->notify_helper(widget, e);
+        break;
+    }
     case QEvent::RequestSoftwareInputPanel:
         inputMethod()->show();
         break;
@@ -4327,6 +4384,17 @@ QWidget *QApplicationPrivate::findClosestTouchPointTarget(QTouchDevice *device,
     return static_cast<QWidget *>(closestTarget);
 }
 
+void QApplicationPrivate::activateImplicitTouchGrab(QWidget *widget, QTouchEvent *touchEvent)
+{
+    if (touchEvent->type() != QEvent::TouchBegin)
+        return;
+
+    for (int i = 0, tc = touchEvent->touchPoints().count(); i < tc; ++i) {
+        const QTouchEvent::TouchPoint &touchPoint = touchEvent->touchPoints().at(i);
+        activeTouchPoints[QGuiApplicationPrivate::ActiveTouchPointsKey(touchEvent->device(), touchPoint.id())].target = widget;
+    }
+}
+
 bool QApplicationPrivate::translateRawTouchEvent(QWidget *window,
                                                  QTouchDevice *device,
                                                  const QList<QTouchEvent::TouchPoint> &touchPoints,
@@ -4457,10 +4525,11 @@ bool QApplicationPrivate::translateRawTouchEvent(QWidget *window,
                 || QGestureManager::gesturePending(widget)
 #endif
                 ) {
-                if (touchEvent.type() == QEvent::TouchEnd)
-                    widget->setAttribute(Qt::WA_WState_AcceptedTouchBeginEvent, false);
                 if (QApplication::sendSpontaneousEvent(widget, &touchEvent) && touchEvent.isAccepted())
                     accepted = true;
+                // widget can be deleted on TouchEnd
+                if (touchEvent.type() == QEvent::TouchEnd && !widget.isNull())
+                    widget->setAttribute(Qt::WA_WState_AcceptedTouchBeginEvent, false);
             }
             break;
         }
diff --git a/src/widgets/kernel/qapplication_p.h b/src/widgets/kernel/qapplication_p.h
index 0482f83a8a5..3358cce7442 100644
--- a/src/widgets/kernel/qapplication_p.h
+++ b/src/widgets/kernel/qapplication_p.h
@@ -156,7 +156,7 @@ public:
 
     bool notify_helper(QObject *receiver, QEvent * e);
 
-    void construct(
+    void init(
 #ifdef Q_DEAD_CODE_FROM_QT4_X11
                    Display *dpy = 0, Qt::HANDLE visual = 0, Qt::HANDLE cmap = 0
 #endif
@@ -208,7 +208,7 @@ public:
     static QWidget *active_window;
 #ifndef QT_NO_WHEELEVENT
     static int  wheel_scroll_lines;
-    static QWidget *wheel_widget;
+    static QPointer<QWidget> wheel_widget;
 #endif
 
     static int enabledAnimations; // Combination of QPlatformTheme::UiEffect
@@ -288,6 +288,7 @@ public:
     QWidget *findClosestTouchPointTarget(QTouchDevice *device, const QTouchEvent::TouchPoint &touchPoint);
     void appendTouchPoint(const QTouchEvent::TouchPoint &touchPoint);
     void removeTouchPoint(int touchPointId);
+    void activateImplicitTouchGrab(QWidget *widget, QTouchEvent *touchBeginEvent);
     static bool translateRawTouchEvent(QWidget *widget,
                                        QTouchDevice *device,
                                        const QList<QTouchEvent::TouchPoint> &touchPoints,
diff --git a/src/widgets/kernel/qboxlayout.cpp b/src/widgets/kernel/qboxlayout.cpp
index d1676904680..f2e3df5314f 100644
--- a/src/widgets/kernel/qboxlayout.cpp
+++ b/src/widgets/kernel/qboxlayout.cpp
@@ -1354,3 +1354,5 @@ QVBoxLayout::~QVBoxLayout()
 }
 
 QT_END_NAMESPACE
+
+#include "moc_qboxlayout.cpp"
diff --git a/src/widgets/kernel/qdesktopwidget.cpp b/src/widgets/kernel/qdesktopwidget.cpp
index 488665ff5f5..fceb0618672 100644
--- a/src/widgets/kernel/qdesktopwidget.cpp
+++ b/src/widgets/kernel/qdesktopwidget.cpp
@@ -274,3 +274,4 @@ void QDesktopWidget::resizeEvent(QResizeEvent *)
 QT_END_NAMESPACE
 
 #include "moc_qdesktopwidget.cpp"
+#include "moc_qdesktopwidget_p.cpp"
diff --git a/src/widgets/kernel/qformlayout.cpp b/src/widgets/kernel/qformlayout.cpp
index 2ee7716ac3f..9b346a2c503 100644
--- a/src/widgets/kernel/qformlayout.cpp
+++ b/src/widgets/kernel/qformlayout.cpp
@@ -2114,3 +2114,5 @@ void QFormLayout::dump() const
 #endif
 
 QT_END_NAMESPACE
+
+#include "moc_qformlayout.cpp"
diff --git a/src/widgets/kernel/qgesturemanager.cpp b/src/widgets/kernel/qgesturemanager.cpp
index 9a3e9291bf3..8af3516d4bc 100644
--- a/src/widgets/kernel/qgesturemanager.cpp
+++ b/src/widgets/kernel/qgesturemanager.cpp
@@ -555,9 +555,9 @@ bool QGestureManager::filterEvent(QObject *receiver, QEvent *event)
     if (widgetWindow)
         return filterEvent(widgetWindow->widget(), event);
 
-    if (!m_gestureToRecognizer.contains(static_cast<QGesture *>(receiver)))
+    QGesture *state = qobject_cast<QGesture *>(receiver);
+    if (!state || !m_gestureToRecognizer.contains(state))
         return false;
-    QGesture *state = static_cast<QGesture *>(receiver);
     QMultiMap<QObject *, Qt::GestureType> contexts;
     contexts.insert(state, state->gestureType());
     return filterEventThroughContexts(contexts, event);
diff --git a/src/widgets/kernel/qgridlayout.cpp b/src/widgets/kernel/qgridlayout.cpp
index f3d294bd777..b58e7fdc9e1 100644
--- a/src/widgets/kernel/qgridlayout.cpp
+++ b/src/widgets/kernel/qgridlayout.cpp
@@ -1692,3 +1692,5 @@ void QGridLayout::invalidate()
 }
 
 QT_END_NAMESPACE
+
+#include "moc_qgridlayout.cpp"
diff --git a/src/widgets/kernel/qlayout.cpp b/src/widgets/kernel/qlayout.cpp
index 6c94d81e432..240f525722d 100644
--- a/src/widgets/kernel/qlayout.cpp
+++ b/src/widgets/kernel/qlayout.cpp
@@ -1477,3 +1477,5 @@ QSize QLayout::closestAcceptableSize(const QWidget *widget, const QSize &size)
 }
 
 QT_END_NAMESPACE
+
+#include "moc_qlayout.cpp"
diff --git a/src/widgets/kernel/qopenglwidget.cpp b/src/widgets/kernel/qopenglwidget.cpp
index f3c86ea306d..5071c567636 100644
--- a/src/widgets/kernel/qopenglwidget.cpp
+++ b/src/widgets/kernel/qopenglwidget.cpp
@@ -1349,3 +1349,5 @@ bool QOpenGLWidget::event(QEvent *e)
 }
 
 QT_END_NAMESPACE
+
+#include "moc_qopenglwidget.cpp"
diff --git a/src/widgets/kernel/qshortcut.cpp b/src/widgets/kernel/qshortcut.cpp
index 77efaf16321..bf162249d0a 100644
--- a/src/widgets/kernel/qshortcut.cpp
+++ b/src/widgets/kernel/qshortcut.cpp
@@ -658,3 +658,5 @@ bool QShortcut::event(QEvent *e)
 #endif // QT_NO_SHORTCUT
 
 QT_END_NAMESPACE
+
+#include "moc_qshortcut.cpp"
diff --git a/src/widgets/kernel/qsizepolicy.cpp b/src/widgets/kernel/qsizepolicy.cpp
index 63024fcf427..66fa350f81a 100644
--- a/src/widgets/kernel/qsizepolicy.cpp
+++ b/src/widgets/kernel/qsizepolicy.cpp
@@ -512,3 +512,5 @@ QDebug operator<<(QDebug dbg, const QSizePolicy &p)
 #endif
 
 QT_END_NAMESPACE
+
+#include "moc_qsizepolicy.cpp"
diff --git a/src/widgets/kernel/qstackedlayout.cpp b/src/widgets/kernel/qstackedlayout.cpp
index 05f7f39f0f4..006b3e85889 100644
--- a/src/widgets/kernel/qstackedlayout.cpp
+++ b/src/widgets/kernel/qstackedlayout.cpp
@@ -596,3 +596,5 @@ void QStackedLayout::setStackingMode(StackingMode stackingMode)
 }
 
 QT_END_NAMESPACE
+
+#include "moc_qstackedlayout.cpp"
diff --git a/src/widgets/kernel/qwidget.cpp b/src/widgets/kernel/qwidget.cpp
index a5b64e5bfc4..598991bd982 100644
--- a/src/widgets/kernel/qwidget.cpp
+++ b/src/widgets/kernel/qwidget.cpp
@@ -1892,7 +1892,6 @@ void QWidgetPrivate::deleteTLSysExtra()
         if (extra->topextra->window) {
             extra->topextra->window->destroy();
         }
-        setWinId(0);
         delete extra->topextra->window;
         extra->topextra->window = 0;
 
@@ -7244,7 +7243,7 @@ void QWidgetPrivate::setGeometry_sys(int x, int y, int w, int h, bool isMove)
             if (q->isVisible())
                 hide_sys();
             data.crect = QRect(x, y, w, h);
-        } else if (q->isVisible() && q->testAttribute(Qt::WA_OutsideWSRange)) {
+        } else if (q->testAttribute(Qt::WA_OutsideWSRange)) {
             q->setAttribute(Qt::WA_OutsideWSRange, false);
             needsShow = true;
         }
diff --git a/src/widgets/kernel/qwidget.h b/src/widgets/kernel/qwidget.h
index cce31e40112..43ca76ac7c7 100644
--- a/src/widgets/kernel/qwidget.h
+++ b/src/widgets/kernel/qwidget.h
@@ -612,43 +612,43 @@ Q_SIGNALS:
 
 protected:
     // Event handlers
-    bool event(QEvent *) Q_DECL_OVERRIDE;
-    virtual void mousePressEvent(QMouseEvent *);
-    virtual void mouseReleaseEvent(QMouseEvent *);
-    virtual void mouseDoubleClickEvent(QMouseEvent *);
-    virtual void mouseMoveEvent(QMouseEvent *);
+    bool event(QEvent *event) Q_DECL_OVERRIDE;
+    virtual void mousePressEvent(QMouseEvent *event);
+    virtual void mouseReleaseEvent(QMouseEvent *event);
+    virtual void mouseDoubleClickEvent(QMouseEvent *event);
+    virtual void mouseMoveEvent(QMouseEvent *event);
 #ifndef QT_NO_WHEELEVENT
-    virtual void wheelEvent(QWheelEvent *);
+    virtual void wheelEvent(QWheelEvent *event);
 #endif
-    virtual void keyPressEvent(QKeyEvent *);
-    virtual void keyReleaseEvent(QKeyEvent *);
-    virtual void focusInEvent(QFocusEvent *);
-    virtual void focusOutEvent(QFocusEvent *);
-    virtual void enterEvent(QEvent *);
-    virtual void leaveEvent(QEvent *);
-    virtual void paintEvent(QPaintEvent *);
-    virtual void moveEvent(QMoveEvent *);
-    virtual void resizeEvent(QResizeEvent *);
-    virtual void closeEvent(QCloseEvent *);
+    virtual void keyPressEvent(QKeyEvent *event);
+    virtual void keyReleaseEvent(QKeyEvent *event);
+    virtual void focusInEvent(QFocusEvent *event);
+    virtual void focusOutEvent(QFocusEvent *event);
+    virtual void enterEvent(QEvent *event);
+    virtual void leaveEvent(QEvent *event);
+    virtual void paintEvent(QPaintEvent *event);
+    virtual void moveEvent(QMoveEvent *event);
+    virtual void resizeEvent(QResizeEvent *event);
+    virtual void closeEvent(QCloseEvent *event);
 #ifndef QT_NO_CONTEXTMENU
-    virtual void contextMenuEvent(QContextMenuEvent *);
+    virtual void contextMenuEvent(QContextMenuEvent *event);
 #endif
 #ifndef QT_NO_TABLETEVENT
-    virtual void tabletEvent(QTabletEvent *);
+    virtual void tabletEvent(QTabletEvent *event);
 #endif
 #ifndef QT_NO_ACTION
-    virtual void actionEvent(QActionEvent *);
+    virtual void actionEvent(QActionEvent *event);
 #endif
 
 #ifndef QT_NO_DRAGANDDROP
-    virtual void dragEnterEvent(QDragEnterEvent *);
-    virtual void dragMoveEvent(QDragMoveEvent *);
-    virtual void dragLeaveEvent(QDragLeaveEvent *);
-    virtual void dropEvent(QDropEvent *);
+    virtual void dragEnterEvent(QDragEnterEvent *event);
+    virtual void dragMoveEvent(QDragMoveEvent *event);
+    virtual void dragLeaveEvent(QDragLeaveEvent *event);
+    virtual void dropEvent(QDropEvent *event);
 #endif
 
-    virtual void showEvent(QShowEvent *);
-    virtual void hideEvent(QHideEvent *);
+    virtual void showEvent(QShowEvent *event);
+    virtual void hideEvent(QHideEvent *event);
     virtual bool nativeEvent(const QByteArray &eventType, void *message, long *result);
 
     // Misc. protected functions
diff --git a/src/widgets/kernel/qwidget_p.h b/src/widgets/kernel/qwidget_p.h
index fe5b3cc85d2..91af7a4cb05 100644
--- a/src/widgets/kernel/qwidget_p.h
+++ b/src/widgets/kernel/qwidget_p.h
@@ -74,7 +74,6 @@ QT_BEGIN_NAMESPACE
 // Extra QWidget data
 //  - to minimize memory usage for members that are seldom used.
 //  - top-level widgets have extra extra data to reduce cost further
-class QWidgetWindow;
 class QPaintEngine;
 class QPixmap;
 class QWidgetBackingStore;
@@ -160,7 +159,7 @@ struct QTLWExtra {
     QWidgetBackingStoreTracker backingStoreTracker;
     QBackingStore *backingStore;
     QPainter *sharedPainter;
-    QWidgetWindow *window;
+    QWindow *window;
     QOpenGLContext *shareContext;
 
     // Implicit pointers (shared_null).
diff --git a/src/widgets/kernel/qwidgetbackingstore.cpp b/src/widgets/kernel/qwidgetbackingstore.cpp
index e925475b79d..7a4a6d862db 100644
--- a/src/widgets/kernel/qwidgetbackingstore.cpp
+++ b/src/widgets/kernel/qwidgetbackingstore.cpp
@@ -1630,3 +1630,5 @@ void QWidgetPrivate::repaint_sys(const QRegion &rgn)
 
 
 QT_END_NAMESPACE
+
+#include "moc_qwidgetbackingstore_p.cpp"
diff --git a/src/widgets/kernel/qwidgetwindow.cpp b/src/widgets/kernel/qwidgetwindow.cpp
index 6a3785ea030..c22841dd56e 100644
--- a/src/widgets/kernel/qwidgetwindow.cpp
+++ b/src/widgets/kernel/qwidgetwindow.cpp
@@ -776,7 +776,7 @@ void QWidgetWindow::handleWheelEvent(QWheelEvent *event)
 
     QPoint mapped = widget->mapFrom(rootWidget, pos);
 
-    QWheelEvent translated(mapped, event->globalPos(), event->pixelDelta(), event->angleDelta(), event->delta(), event->orientation(), event->buttons(), event->modifiers(), event->phase(), event->source());
+    QWheelEvent translated(mapped, event->globalPos(), event->pixelDelta(), event->angleDelta(), event->delta(), event->orientation(), event->buttons(), event->modifiers(), event->phase(), event->source(), event->inverted());
     QGuiApplication::sendSpontaneousEvent(widget, &translated);
 }
 
@@ -1007,3 +1007,5 @@ void QWidgetWindow::updateObjectName()
 }
 
 QT_END_NAMESPACE
+
+#include "moc_qwidgetwindow_p.cpp"
diff --git a/src/widgets/kernel/qwindowcontainer.cpp b/src/widgets/kernel/qwindowcontainer.cpp
index 462a41ce5d2..d7f4b1f989a 100644
--- a/src/widgets/kernel/qwindowcontainer.cpp
+++ b/src/widgets/kernel/qwindowcontainer.cpp
@@ -403,3 +403,5 @@ void QWindowContainer::parentWasLowered(QWidget *parent)
 }
 
 QT_END_NAMESPACE
+
+#include "moc_qwindowcontainer_p.cpp"
diff --git a/src/widgets/statemachine/qbasickeyeventtransition.cpp b/src/widgets/statemachine/qbasickeyeventtransition.cpp
index e1b4e262e80..fe2edca6139 100644
--- a/src/widgets/statemachine/qbasickeyeventtransition.cpp
+++ b/src/widgets/statemachine/qbasickeyeventtransition.cpp
@@ -203,4 +203,6 @@ void QBasicKeyEventTransition::onTransition(QEvent *)
 
 QT_END_NAMESPACE
 
+#include "moc_qbasickeyeventtransition_p.cpp"
+
 #endif //QT_NO_STATEMACHINE
diff --git a/src/widgets/statemachine/qbasicmouseeventtransition.cpp b/src/widgets/statemachine/qbasicmouseeventtransition.cpp
index 6ca76ce1b10..39c69b95f56 100644
--- a/src/widgets/statemachine/qbasicmouseeventtransition.cpp
+++ b/src/widgets/statemachine/qbasicmouseeventtransition.cpp
@@ -208,4 +208,6 @@ void QBasicMouseEventTransition::onTransition(QEvent *)
 
 QT_END_NAMESPACE
 
+#include "moc_qbasicmouseeventtransition_p.cpp"
+
 #endif //QT_NO_STATEMACHINE
diff --git a/src/widgets/statemachine/qkeyeventtransition.cpp b/src/widgets/statemachine/qkeyeventtransition.cpp
index ef5151d1ebd..0e9f8458c23 100644
--- a/src/widgets/statemachine/qkeyeventtransition.cpp
+++ b/src/widgets/statemachine/qkeyeventtransition.cpp
@@ -174,4 +174,6 @@ void QKeyEventTransition::onTransition(QEvent *event)
 
 QT_END_NAMESPACE
 
+#include "moc_qkeyeventtransition.cpp"
+
 #endif //QT_NO_STATEMACHINE
diff --git a/src/widgets/statemachine/qmouseeventtransition.cpp b/src/widgets/statemachine/qmouseeventtransition.cpp
index d287bb23aa6..047a9779feb 100644
--- a/src/widgets/statemachine/qmouseeventtransition.cpp
+++ b/src/widgets/statemachine/qmouseeventtransition.cpp
@@ -202,4 +202,6 @@ void QMouseEventTransition::onTransition(QEvent *event)
 
 QT_END_NAMESPACE
 
+#include "moc_qmouseeventtransition.cpp"
+
 #endif //QT_NO_STATEMACHINE
diff --git a/src/widgets/styles/qfusionstyle.cpp b/src/widgets/styles/qfusionstyle.cpp
index 1cd91a26ee1..3bab2f5dbec 100644
--- a/src/widgets/styles/qfusionstyle.cpp
+++ b/src/widgets/styles/qfusionstyle.cpp
@@ -3741,4 +3741,6 @@ QPixmap QFusionStyle::standardPixmap(StandardPixmap standardPixmap, const QStyle
 
 QT_END_NAMESPACE
 
+#include "moc_qfusionstyle_p.cpp"
+
 #endif // QT_NO_STYLE_FUSION || QT_PLUGIN
diff --git a/src/widgets/styles/qmacstyle_mac.mm b/src/widgets/styles/qmacstyle_mac.mm
index ef1b9432cde..3d03ed53237 100644
--- a/src/widgets/styles/qmacstyle_mac.mm
+++ b/src/widgets/styles/qmacstyle_mac.mm
@@ -1102,17 +1102,67 @@ static QAquaWidgetSize qt_aqua_guess_size(const QWidget *widg, QSize large, QSiz
 }
 #endif
 
-static void qt_drawFocusRingOnPath(CGContextRef cg, NSBezierPath *focusRingPath)
+void QMacStylePrivate::drawFocusRing(QPainter *p, const QRect &targetRect, int hMargin, int vMargin, qreal radius) const
 {
-    CGContextSaveGState(cg);
-    [NSGraphicsContext saveGraphicsState];
-    [NSGraphicsContext setCurrentContext:[NSGraphicsContext
-         graphicsContextWithGraphicsPort:(CGContextRef)cg flipped:NO]];
-    NSSetFocusRingStyle(NSFocusRingOnly);
-    [focusRingPath setClip]; // Clear clip path to avoid artifacts when rendering the cursor at zero pos
-    [focusRingPath fill];
-    [NSGraphicsContext restoreGraphicsState];
-    CGContextRestoreGState(cg);
+    qreal pixelRatio = p->device()->devicePixelRatioF();
+    static const QString keyFormat = QLatin1String("$qt_focusring%1-%2-%3-%4");
+    const QString &key = keyFormat.arg(hMargin).arg(vMargin).arg(radius).arg(pixelRatio);
+    QPixmap focusRingPixmap;
+    const qreal size = radius * 2 + 5;
+
+    if (!QPixmapCache::find(key, focusRingPixmap)) {
+        focusRingPixmap = QPixmap((QSize(size, size) + 2 * QSize(hMargin, vMargin)) * pixelRatio);
+        focusRingPixmap.fill(Qt::transparent);
+        focusRingPixmap.setDevicePixelRatio(pixelRatio);
+        {
+            QMacAutoReleasePool pool;
+            NSBezierPath *focusRingPath;
+            if (radius > 0)
+                focusRingPath = [NSBezierPath bezierPathWithRoundedRect:NSMakeRect(hMargin, vMargin, size, size)
+                                                                xRadius:radius
+                                                                yRadius:radius];
+            else
+                focusRingPath = [NSBezierPath bezierPathWithRect:NSMakeRect(hMargin, vMargin, size, size)];
+            [NSGraphicsContext saveGraphicsState];
+            QMacCGContext gc(&focusRingPixmap);
+            [NSGraphicsContext setCurrentContext:[NSGraphicsContext graphicsContextWithGraphicsPort:(CGContextRef)gc
+                                                                                            flipped:NO]];
+            NSSetFocusRingStyle(NSFocusRingOnly);
+            [focusRingPath fill];
+            [NSGraphicsContext restoreGraphicsState];
+        }
+        QPixmapCache::insert(key, focusRingPixmap);
+    }
+
+    // Add 2 for the actual ring tickness going inwards
+    const qreal hCornerSize = 2 + hMargin + radius;
+    const qreal vCornerSize = 2 + vMargin + radius;
+    const qreal shCornerSize = hCornerSize * pixelRatio;
+    const qreal svCornerSize = vCornerSize * pixelRatio;
+    // top-left corner
+    p->drawPixmap(QPointF(targetRect.left(), targetRect.top()), focusRingPixmap,
+                  QRectF(0, 0, shCornerSize, svCornerSize));
+    // top-right corner
+    p->drawPixmap(QPointF(targetRect.right() - hCornerSize + 1, targetRect.top()), focusRingPixmap,
+                  QRectF(focusRingPixmap.width() - shCornerSize, 0, shCornerSize, svCornerSize));
+    // bottom-left corner
+    p->drawPixmap(QPointF(targetRect.left(), targetRect.bottom() - vCornerSize + 1), focusRingPixmap,
+                  QRectF(0, focusRingPixmap.height() - svCornerSize, shCornerSize, svCornerSize));
+    // bottom-right corner
+    p->drawPixmap(QPointF(targetRect.right() - hCornerSize + 1, targetRect.bottom() - vCornerSize + 1), focusRingPixmap,
+                  QRect(focusRingPixmap.width() - shCornerSize, focusRingPixmap.height() - svCornerSize, shCornerSize, svCornerSize));
+    // top edge
+    p->drawPixmap(QRectF(targetRect.left() + hCornerSize, targetRect.top(), targetRect.width() - 2 * hCornerSize, vCornerSize), focusRingPixmap,
+                  QRect(shCornerSize, 0, focusRingPixmap.width() - 2 * shCornerSize, svCornerSize));
+    // bottom edge
+    p->drawPixmap(QRectF(targetRect.left() + hCornerSize, targetRect.bottom() - vCornerSize + 1, targetRect.width() - 2 * hCornerSize, vCornerSize), focusRingPixmap,
+                  QRect(shCornerSize, focusRingPixmap.height() - svCornerSize, focusRingPixmap.width() - 2 * shCornerSize, svCornerSize));
+    // left edge
+    p->drawPixmap(QRectF(targetRect.left(), targetRect.top() + vCornerSize, hCornerSize, targetRect.height() - 2 * vCornerSize), focusRingPixmap,
+                  QRect(0, svCornerSize, shCornerSize, focusRingPixmap.width() - 2 * svCornerSize));
+    // right edge
+    p->drawPixmap(QRectF(targetRect.right() - hCornerSize + 1, targetRect.top() + vCornerSize, hCornerSize, targetRect.height() - 2 * vCornerSize), focusRingPixmap,
+                  QRect(focusRingPixmap.width() - shCornerSize, svCornerSize, shCornerSize, focusRingPixmap.width() - 2 * svCornerSize));
 }
 
 QAquaWidgetSize QMacStylePrivate::effectiveAquaSizeConstrain(const QStyleOption *option,
@@ -3922,12 +3972,11 @@ void QMacStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPainter
                     }
                 }
 
-                NSBezierPath *pushButtonFocusRingPath;
-                if (bdi.kind == kThemeBevelButton)
-                    pushButtonFocusRingPath = [NSBezierPath bezierPathWithRect:NSRectFromCGRect(focusRect)];
-                else
-                    pushButtonFocusRingPath = [NSBezierPath bezierPathWithRoundedRect:NSRectFromCGRect(focusRect) xRadius:4 yRadius:4];
-                qt_drawFocusRingOnPath(cg, pushButtonFocusRingPath);
+                const qreal radius = bdi.kind == kThemeBevelButton ? 0 : 4;
+                const int hMargin = proxy()->pixelMetric(QStyle::PM_FocusFrameHMargin, btn, w);
+                const int vMargin = proxy()->pixelMetric(QStyle::PM_FocusFrameVMargin, btn, w);
+                const QRect focusTargetRect(focusRect.origin.x, focusRect.origin.y, focusRect.size.width, focusRect.size.height);
+                d->drawFocusRing(p, focusTargetRect.adjusted(-hMargin, -vMargin, hMargin, vMargin), hMargin, vMargin, radius);
             }
 
             if (hasMenu && (!usingYosemiteOrLater || bdi.kind == kThemeBevelButton)) {
@@ -4365,12 +4414,9 @@ void QMacStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPainter
         }
         break;
     case CE_FocusFrame: {
-        int xOff = proxy()->pixelMetric(PM_FocusFrameHMargin, opt, w);
-        int yOff = proxy()->pixelMetric(PM_FocusFrameVMargin, opt, w);
-        NSRect rect = NSMakeRect(xOff+opt->rect.x(), yOff+opt->rect.y(), opt->rect.width() - 2 * xOff,
-                                 opt->rect.height() - 2 * yOff);
-        NSBezierPath *focusFramePath = [NSBezierPath bezierPathWithRect:rect];
-        qt_drawFocusRingOnPath(cg, focusFramePath);
+        const int hMargin = proxy()->pixelMetric(QStyle::PM_FocusFrameHMargin, opt, w);
+        const int vMargin = proxy()->pixelMetric(QStyle::PM_FocusFrameVMargin, opt, w);
+        d->drawFocusRing(p, opt->rect, hMargin, vMargin);
         break; }
     case CE_MenuItem:
     case CE_MenuEmptyArea:
@@ -4582,7 +4628,8 @@ void QMacStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPainter
             HIRect menuRect = qt_hirectForQRect(mi->menuRect);
             HIRect itemRect = qt_hirectForQRect(mi->rect);
 
-            if ((opt->state & State_Selected) && (opt->state & State_Enabled) && (opt->state & State_Sunken)){
+            const bool selected = (opt->state & State_Selected) && (opt->state & State_Enabled) && (opt->state & State_Sunken);
+            if (selected) {
                 // Draw a selected menu item background:
                 HIThemeMenuItemDrawInfo mdi;
                 mdi.version = qt_mac_hitheme_version;
@@ -4610,7 +4657,7 @@ void QMacStyle::drawControl(ControlElement ce, const QStyleOption *opt, QPainter
                                 Qt::AlignCenter | Qt::TextHideMnemonic | Qt::TextDontClip
                                 | Qt::TextSingleLine,
                                 mi->palette, mi->state & State_Enabled,
-                                mi->text, QPalette::ButtonText);
+                                mi->text, selected ? QPalette::HighlightedText : QPalette::ButtonText);
             }
         }
         break;
diff --git a/src/widgets/styles/qmacstyle_mac_p_p.h b/src/widgets/styles/qmacstyle_mac_p_p.h
index 53dd2b7a237..31ba8c3464c 100644
--- a/src/widgets/styles/qmacstyle_mac_p_p.h
+++ b/src/widgets/styles/qmacstyle_mac_p_p.h
@@ -218,6 +218,8 @@ public:
     void drawNSViewInRect(QCocoaWidget widget, NSView *view, const QRect &rect, QPainter *p, bool isQWidget = true, QCocoaDrawRectBlock drawRectBlock = nil) const;
     void resolveCurrentNSView(QWindow *window);
 
+    void drawFocusRing(QPainter *p, const QRect &targetRect, int hMargin, int vMargin, qreal radius = 0) const;
+
 public:
     mutable QPointer<QObject> pressedButton;
     mutable QPointer<QObject> defaultButton;
diff --git a/src/widgets/styles/qproxystyle.cpp b/src/widgets/styles/qproxystyle.cpp
index df152d1f39a..182c9747298 100644
--- a/src/widgets/styles/qproxystyle.cpp
+++ b/src/widgets/styles/qproxystyle.cpp
@@ -429,4 +429,6 @@ int QProxyStyle::layoutSpacing(QSizePolicy::ControlType control1,
 
 QT_END_NAMESPACE
 
+#include "moc_qproxystyle.cpp"
+
 #endif // QT_NO_STYLE_PROXY
diff --git a/src/widgets/styles/qstyle.cpp b/src/widgets/styles/qstyle.cpp
index 26bb227e295..103c49496ef 100644
--- a/src/widgets/styles/qstyle.cpp
+++ b/src/widgets/styles/qstyle.cpp
@@ -2424,3 +2424,5 @@ void QStyle::setProxy(QStyle *style)
 }
 
 QT_END_NAMESPACE
+
+#include "moc_qstyle.cpp"
diff --git a/src/widgets/styles/qstyle.h b/src/widgets/styles/qstyle.h
index 0f9c9379f5a..0f1259160e7 100644
--- a/src/widgets/styles/qstyle.h
+++ b/src/widgets/styles/qstyle.h
@@ -72,13 +72,13 @@ public:
     QStyle();
     virtual ~QStyle();
 
-    virtual void polish(QWidget *);
-    virtual void unpolish(QWidget *);
+    virtual void polish(QWidget *widget);
+    virtual void unpolish(QWidget *widget);
 
-    virtual void polish(QApplication *);
-    virtual void unpolish(QApplication *);
+    virtual void polish(QApplication *application);
+    virtual void unpolish(QApplication *application);
 
-    virtual void polish(QPalette &);
+    virtual void polish(QPalette &palette);
 
     virtual QRect itemTextRect(const QFontMetrics &fm, const QRect &r,
                            int flags, bool enabled,
diff --git a/src/widgets/styles/qstyleanimation.cpp b/src/widgets/styles/qstyleanimation.cpp
index 53af663dcdb..67e2ee32255 100644
--- a/src/widgets/styles/qstyleanimation.cpp
+++ b/src/widgets/styles/qstyleanimation.cpp
@@ -365,4 +365,6 @@ void QScrollbarStyleAnimation::updateCurrentTime(int time)
 
 QT_END_NAMESPACE
 
+#include "moc_qstyleanimation_p.cpp"
+
 #endif //QT_NO_ANIMATION
diff --git a/src/widgets/styles/qstyleplugin.cpp b/src/widgets/styles/qstyleplugin.cpp
index 464cc95827f..b29ff0b9a12 100644
--- a/src/widgets/styles/qstyleplugin.cpp
+++ b/src/widgets/styles/qstyleplugin.cpp
@@ -105,3 +105,5 @@ QStylePlugin::~QStylePlugin()
 }
 
 QT_END_NAMESPACE
+
+#include "moc_qstyleplugin.cpp"
diff --git a/src/widgets/styles/qwindowsstyle.cpp b/src/widgets/styles/qwindowsstyle.cpp
index d8af8c5de84..36aa312ce87 100644
--- a/src/widgets/styles/qwindowsstyle.cpp
+++ b/src/widgets/styles/qwindowsstyle.cpp
@@ -2403,4 +2403,6 @@ QIcon QWindowsStyle::standardIcon(StandardPixmap standardIcon, const QStyleOptio
 
 QT_END_NAMESPACE
 
+#include "moc_qwindowsstyle_p.cpp"
+
 #endif // QT_NO_STYLE_WINDOWS
diff --git a/src/widgets/styles/qwindowsstyle_p.h b/src/widgets/styles/qwindowsstyle_p.h
index 37b78c95236..f9d174d3c68 100644
--- a/src/widgets/styles/qwindowsstyle_p.h
+++ b/src/widgets/styles/qwindowsstyle_p.h
@@ -103,7 +103,6 @@ protected:
 private:
     Q_DISABLE_COPY(QWindowsStyle)
     Q_DECLARE_PRIVATE(QWindowsStyle)
-    void *reserved;
 };
 
 #endif // QT_NO_STYLE_WINDOWS
diff --git a/src/widgets/styles/qwindowsxpstyle_p.h b/src/widgets/styles/qwindowsxpstyle_p.h
index a3981ad1047..61bb5085119 100644
--- a/src/widgets/styles/qwindowsxpstyle_p.h
+++ b/src/widgets/styles/qwindowsxpstyle_p.h
@@ -99,7 +99,6 @@ private:
     Q_DISABLE_COPY(QWindowsXPStyle)
     Q_DECLARE_PRIVATE(QWindowsXPStyle)
     friend class QStyleFactory;
-    void *reserved;
 };
 
 #endif // QT_NO_STYLE_WINDOWSXP
diff --git a/src/widgets/styles/qwindowsxpstyle_p_p.h b/src/widgets/styles/qwindowsxpstyle_p_p.h
index 7daef62ce0e..31977304fe4 100644
--- a/src/widgets/styles/qwindowsxpstyle_p_p.h
+++ b/src/widgets/styles/qwindowsxpstyle_p_p.h
@@ -56,18 +56,6 @@
 #include <qmap.h>
 #include <qt_windows.h>
 
-// Note, these tests are duplicated in qwizard_win.cpp.
-#ifdef Q_CC_GNU
-#  include <w32api.h>
-#  if (__W32API_MAJOR_VERSION >= 3 || (__W32API_MAJOR_VERSION == 2 && __W32API_MINOR_VERSION >= 5))
-#    ifdef _WIN32_WINNT
-#      undef _WIN32_WINNT
-#    endif
-#    define _WIN32_WINNT 0x0501
-#    include <commctrl.h>
-#  endif
-#endif
-
 #include <uxtheme.h>
 
 #if WINVER >= 0x0600
diff --git a/src/widgets/util/qcompleter.cpp b/src/widgets/util/qcompleter.cpp
index 9f167f59245..083a4a4f27e 100644
--- a/src/widgets/util/qcompleter.cpp
+++ b/src/widgets/util/qcompleter.cpp
@@ -1886,4 +1886,6 @@ QT_END_NAMESPACE
 
 #include "moc_qcompleter.cpp"
 
+#include "moc_qcompleter_p.cpp"
+
 #endif // QT_NO_COMPLETER
diff --git a/src/widgets/util/qcompleter_p.h b/src/widgets/util/qcompleter_p.h
index e2b65ba2110..10dde975c0f 100644
--- a/src/widgets/util/qcompleter_p.h
+++ b/src/widgets/util/qcompleter_p.h
@@ -128,7 +128,7 @@ private:
 };
 
 struct QMatchData {
-    QMatchData() : exactMatchIndex(-1) { }
+    QMatchData() : exactMatchIndex(-1), partial(false) { }
     QMatchData(const QIndexMapper& indices, int em, bool p) :
         indices(indices), exactMatchIndex(em), partial(p) { }
     QIndexMapper indices;
diff --git a/src/widgets/util/qflickgesture.cpp b/src/widgets/util/qflickgesture.cpp
index 933db1711b4..4f08664784e 100644
--- a/src/widgets/util/qflickgesture.cpp
+++ b/src/widgets/util/qflickgesture.cpp
@@ -715,4 +715,6 @@ void QFlickGestureRecognizer::reset(QGesture *state)
 
 QT_END_NAMESPACE
 
+#include "moc_qflickgesture_p.cpp"
+
 #endif // QT_NO_GESTURES
diff --git a/src/widgets/util/qscroller.cpp b/src/widgets/util/qscroller.cpp
index 02e3c2b82a8..2e482084021 100644
--- a/src/widgets/util/qscroller.cpp
+++ b/src/widgets/util/qscroller.cpp
@@ -2063,3 +2063,6 @@ qreal QScrollerPrivate::nextSnapPos(qreal p, int dir, Qt::Orientation orientatio
 */
 
 QT_END_NAMESPACE
+
+#include "moc_qscroller.cpp"
+#include "moc_qscroller_p.cpp"
diff --git a/src/widgets/util/qsystemtrayicon.cpp b/src/widgets/util/qsystemtrayicon.cpp
index 59f7fae28ee..3606b7c7731 100644
--- a/src/widgets/util/qsystemtrayicon.cpp
+++ b/src/widgets/util/qsystemtrayicon.cpp
@@ -772,3 +772,4 @@ QT_END_NAMESPACE
 #endif // QT_NO_SYSTEMTRAYICON
 
 #include "moc_qsystemtrayicon.cpp"
+#include "moc_qsystemtrayicon_p.cpp"
diff --git a/src/widgets/util/qsystemtrayicon_win.cpp b/src/widgets/util/qsystemtrayicon_win.cpp
index adf193bb668..f34714c0161 100644
--- a/src/widgets/util/qsystemtrayicon_win.cpp
+++ b/src/widgets/util/qsystemtrayicon_win.cpp
@@ -40,13 +40,6 @@
 #include "qsystemtrayicon_p.h"
 #ifndef QT_NO_SYSTEMTRAYICON
 
-#if defined(_WIN32_WINNT) && _WIN32_WINNT < 0x0600
-#  undef _WIN32_WINNT
-#endif
-#if !defined(_WIN32_WINNT)
-#  define _WIN32_WINNT 0x0600
-#endif
-
 #if defined(_WIN32_IE) && _WIN32_IE < 0x0600
 #  undef _WIN32_IE
 #endif
diff --git a/src/widgets/util/qundogroup.cpp b/src/widgets/util/qundogroup.cpp
index c8623f44feb..ec4fc2788ac 100644
--- a/src/widgets/util/qundogroup.cpp
+++ b/src/widgets/util/qundogroup.cpp
@@ -501,4 +501,6 @@ QAction *QUndoGroup::createRedoAction(QObject *parent, const QString &prefix) co
 
 QT_END_NAMESPACE
 
+#include "moc_qundogroup.cpp"
+
 #endif // QT_NO_UNDOGROUP
diff --git a/src/widgets/util/qundostack.cpp b/src/widgets/util/qundostack.cpp
index 6f733f99d5d..7f6a56e0ec9 100644
--- a/src/widgets/util/qundostack.cpp
+++ b/src/widgets/util/qundostack.cpp
@@ -1174,4 +1174,7 @@ bool QUndoStack::isActive() const
 
 QT_END_NAMESPACE
 
+#include "moc_qundostack.cpp"
+#include "moc_qundostack_p.cpp"
+
 #endif // QT_NO_UNDOSTACK
diff --git a/src/widgets/util/qundoview.cpp b/src/widgets/util/qundoview.cpp
index 9a89c42a3ea..93c1778ea2f 100644
--- a/src/widgets/util/qundoview.cpp
+++ b/src/widgets/util/qundoview.cpp
@@ -472,5 +472,6 @@ QIcon QUndoView::cleanIcon() const
 QT_END_NAMESPACE
 
 #include "qundoview.moc"
+#include "moc_qundoview.cpp"
 
 #endif // QT_NO_UNDOVIEW
diff --git a/src/widgets/widgets.pro b/src/widgets/widgets.pro
index ceb6f96f7cf..b609e4c4340 100644
--- a/src/widgets/widgets.pro
+++ b/src/widgets/widgets.pro
@@ -8,13 +8,8 @@ DEFINES   += QT_NO_USING_NAMESPACE
 win32-msvc*|win32-icc:QMAKE_LFLAGS += /BASE:0x65000000
 irix-cc*:QMAKE_CXXFLAGS += -no_prelink -ptused
 
-MODULE_PLUGIN_TYPES += \
-    styles
-
 QMAKE_DOCS = $$PWD/doc/qtwidgets.qdocconf
 
-load(qt_module)
-
 #platforms
 mac:include(kernel/mac.pri)
 win32:include(kernel/win.pri)
@@ -45,3 +40,7 @@ QMAKE_DYNAMIC_LIST_FILE = $$PWD/QtWidgets.dynlist
 testcocoon {
     load(testcocoon)
 }
+
+MODULE_PLUGIN_TYPES += \
+    styles
+load(qt_module)
diff --git a/src/widgets/widgets/qabstractbutton.cpp b/src/widgets/widgets/qabstractbutton.cpp
index 9133664d774..44123d4ddaf 100644
--- a/src/widgets/widgets/qabstractbutton.cpp
+++ b/src/widgets/widgets/qabstractbutton.cpp
@@ -37,7 +37,9 @@
 **
 ****************************************************************************/
 
-#include "qabstractbutton.h"
+#include "private/qabstractbutton_p.h"
+
+#include "private/qbuttongroup_p.h"
 #include "qabstractitemview.h"
 #include "qbuttongroup.h"
 #include "qabstractbutton_p.h"
@@ -177,137 +179,6 @@ QAbstractButtonPrivate::QAbstractButtonPrivate(QSizePolicy::ControlType type)
     controlType(type)
 {}
 
-#ifndef QT_NO_BUTTONGROUP
-
-class QButtonGroupPrivate: public QObjectPrivate
-{
-    Q_DECLARE_PUBLIC(QButtonGroup)
-
-public:
-    QButtonGroupPrivate():exclusive(true){}
-    QList<QAbstractButton *> buttonList;
-    QPointer<QAbstractButton> checkedButton;
-    void detectCheckedButton();
-    void notifyChecked(QAbstractButton *button);
-    bool exclusive;
-    QHash<QAbstractButton*, int> mapping;
-};
-
-QButtonGroup::QButtonGroup(QObject *parent)
-    : QObject(*new QButtonGroupPrivate, parent)
-{
-}
-
-QButtonGroup::~QButtonGroup()
-{
-    Q_D(QButtonGroup);
-    for (int i = 0; i < d->buttonList.count(); ++i)
-        d->buttonList.at(i)->d_func()->group = 0;
-}
-
-
-bool QButtonGroup::exclusive() const
-{
-    Q_D(const QButtonGroup);
-    return d->exclusive;
-}
-
-void QButtonGroup::setExclusive(bool exclusive)
-{
-    Q_D(QButtonGroup);
-    d->exclusive = exclusive;
-}
-
-
-void QButtonGroup::addButton(QAbstractButton *button, int id)
-{
-    Q_D(QButtonGroup);
-    if (QButtonGroup *previous = button->d_func()->group)
-        previous->removeButton(button);
-    button->d_func()->group = this;
-    d->buttonList.append(button);
-    if (id == -1) {
-        const QHash<QAbstractButton*, int>::const_iterator it
-                = std::min_element(d->mapping.cbegin(), d->mapping.cend());
-        if (it == d->mapping.cend())
-            d->mapping[button] = -2;
-        else
-            d->mapping[button] = *it - 1;
-    } else {
-        d->mapping[button] = id;
-    }
-
-    if (d->exclusive && button->isChecked())
-        button->d_func()->notifyChecked();
-}
-
-void QButtonGroup::removeButton(QAbstractButton *button)
-{
-    Q_D(QButtonGroup);
-    if (d->checkedButton == button) {
-        d->detectCheckedButton();
-    }
-    if (button->d_func()->group == this) {
-        button->d_func()->group = 0;
-        d->buttonList.removeAll(button);
-        d->mapping.remove(button);
-    }
-}
-
-QList<QAbstractButton*> QButtonGroup::buttons() const
-{
-    Q_D(const QButtonGroup);
-    return d->buttonList;
-}
-
-QAbstractButton *QButtonGroup::checkedButton() const
-{
-    Q_D(const QButtonGroup);
-    return d->checkedButton;
-}
-
-QAbstractButton *QButtonGroup::button(int id) const
-{
-    Q_D(const QButtonGroup);
-    return d->mapping.key(id);
-}
-
-void QButtonGroup::setId(QAbstractButton *button, int id)
-{
-    Q_D(QButtonGroup);
-    if (button && id != -1)
-        d->mapping[button] = id;
-}
-
-int QButtonGroup::id(QAbstractButton *button) const
-{
-    Q_D(const QButtonGroup);
-    return d->mapping.value(button, -1);
-}
-
-int QButtonGroup::checkedId() const
-{
-    Q_D(const QButtonGroup);
-    return d->mapping.value(d->checkedButton, -1);
-}
-
-// detect a checked button other than the current one
-void QButtonGroupPrivate::detectCheckedButton()
-{
-    QAbstractButton *previous = checkedButton;
-    checkedButton = 0;
-    if (exclusive)
-        return;
-    for (int i = 0; i < buttonList.count(); i++) {
-        if (buttonList.at(i) != previous && buttonList.at(i)->isChecked()) {
-            checkedButton = buttonList.at(i);
-            return;
-        }
-    }
-}
-
-#endif // QT_NO_BUTTONGROUP
-
 QList<QAbstractButton *>QAbstractButtonPrivate::queryButtonList() const
 {
 #ifndef QT_NO_BUTTONGROUP
@@ -1419,3 +1290,5 @@ void QAbstractButton::setIconSize(const QSize &size)
 
 
 QT_END_NAMESPACE
+
+#include "moc_qabstractbutton.cpp"
diff --git a/src/widgets/widgets/qabstractbutton_p.h b/src/widgets/widgets/qabstractbutton_p.h
index 416a9c4c836..f65a0527fca 100644
--- a/src/widgets/widgets/qabstractbutton_p.h
+++ b/src/widgets/widgets/qabstractbutton_p.h
@@ -51,6 +51,8 @@
 // We mean it.
 //
 
+#include "qabstractbutton.h"
+
 #include "QtCore/qbasictimer.h"
 #include "private/qwidget_p.h"
 
diff --git a/src/widgets/widgets/qabstractslider.cpp b/src/widgets/widgets/qabstractslider.cpp
index d7d83c78215..8cd35495e91 100644
--- a/src/widgets/widgets/qabstractslider.cpp
+++ b/src/widgets/widgets/qabstractslider.cpp
@@ -758,6 +758,8 @@ void QAbstractSlider::wheelEvent(QWheelEvent * e)
     Q_D(QAbstractSlider);
     e->ignore();
     int delta = e->delta();
+    if (e->inverted())
+        delta = -delta;
     if (d->scrollByDelta(e->orientation(), e->modifiers(), delta))
         e->accept();
 }
@@ -960,3 +962,5 @@ void QAbstractSliderPrivate::itemviewChangeSingleStep(int step)
 }
 
 QT_END_NAMESPACE
+
+#include "moc_qabstractslider.cpp"
diff --git a/src/widgets/widgets/qbuttongroup.cpp b/src/widgets/widgets/qbuttongroup.cpp
index 7cc260a6f0e..ef73fd1b677 100644
--- a/src/widgets/widgets/qbuttongroup.cpp
+++ b/src/widgets/widgets/qbuttongroup.cpp
@@ -37,7 +37,28 @@
 **
 ****************************************************************************/
 
+#include "private/qbuttongroup_p.h"
 
+#ifndef QT_NO_BUTTONGROUP
+
+#include "private/qabstractbutton_p.h"
+
+QT_BEGIN_NAMESPACE
+
+// detect a checked button other than the current one
+void QButtonGroupPrivate::detectCheckedButton()
+{
+    QAbstractButton *previous = checkedButton;
+    checkedButton = 0;
+    if (exclusive)
+        return;
+    for (int i = 0; i < buttonList.count(); i++) {
+        if (buttonList.at(i) != previous && buttonList.at(i)->isChecked()) {
+            checkedButton = buttonList.at(i);
+            return;
+        }
+    }
+}
 
 /*!
     \class QButtonGroup
@@ -84,18 +105,24 @@
 */
 
 /*!
-    \fn QButtonGroup::QButtonGroup(QObject *parent)
-
     Constructs a new, empty button group with the given \a parent.
 
     \sa addButton(), setExclusive()
 */
+QButtonGroup::QButtonGroup(QObject *parent)
+    : QObject(*new QButtonGroupPrivate, parent)
+{
+}
 
 /*!
-    \fn QButtonGroup::~QButtonGroup()
-
     Destroys the button group.
 */
+QButtonGroup::~QButtonGroup()
+{
+    Q_D(QButtonGroup);
+    for (int i = 0; i < d->buttonList.count(); ++i)
+        d->buttonList.at(i)->d_func()->group = 0;
+}
 
 /*!
     \property QButtonGroup::exclusive
@@ -111,6 +138,19 @@
 
     By default, this property is \c true.
 */
+bool QButtonGroup::exclusive() const
+{
+    Q_D(const QButtonGroup);
+    return d->exclusive;
+}
+
+void QButtonGroup::setExclusive(bool exclusive)
+{
+    Q_D(QButtonGroup);
+    d->exclusive = exclusive;
+}
+
+
 
 /*!
     \fn void QButtonGroup::buttonClicked(QAbstractButton *button)
@@ -193,8 +233,6 @@
 
 
 /*!
-    \fn void QButtonGroup::addButton(QAbstractButton *button, int id = -1);
-
     Adds the given \a button to the button group. If \a id is -1,
     an id will be assigned to the button.
     Automatically assigned ids are guaranteed to be negative,
@@ -203,42 +241,82 @@
 
     \sa removeButton(), buttons()
 */
+void QButtonGroup::addButton(QAbstractButton *button, int id)
+{
+    Q_D(QButtonGroup);
+    if (QButtonGroup *previous = button->d_func()->group)
+        previous->removeButton(button);
+    button->d_func()->group = this;
+    d->buttonList.append(button);
+    if (id == -1) {
+        const QHash<QAbstractButton*, int>::const_iterator it
+                = std::min_element(d->mapping.cbegin(), d->mapping.cend());
+        if (it == d->mapping.cend())
+            d->mapping[button] = -2;
+        else
+            d->mapping[button] = *it - 1;
+    } else {
+        d->mapping[button] = id;
+    }
+
+    if (d->exclusive && button->isChecked())
+        button->d_func()->notifyChecked();
+}
 
 /*!
-    \fn void QButtonGroup::removeButton(QAbstractButton *button);
-
     Removes the given \a button from the button group.
 
     \sa addButton(), buttons()
 */
+void QButtonGroup::removeButton(QAbstractButton *button)
+{
+    Q_D(QButtonGroup);
+    if (d->checkedButton == button) {
+        d->detectCheckedButton();
+    }
+    if (button->d_func()->group == this) {
+        button->d_func()->group = 0;
+        d->buttonList.removeAll(button);
+        d->mapping.remove(button);
+    }
+}
 
 /*!
-    \fn QList<QAbstractButton*> QButtonGroup::buttons() const
-
     Returns the button group's list of buttons. This may be empty.
 
     \sa addButton(), removeButton()
 */
+QList<QAbstractButton*> QButtonGroup::buttons() const
+{
+    Q_D(const QButtonGroup);
+    return d->buttonList;
+}
 
 /*!
-    \fn QAbstractButton *QButtonGroup::checkedButton() const;
-
     Returns the button group's checked button, or 0 if no buttons are
     checked.
 
     \sa buttonClicked()
 */
+QAbstractButton *QButtonGroup::checkedButton() const
+{
+    Q_D(const QButtonGroup);
+    return d->checkedButton;
+}
 
 /*!
-    \fn QAbstractButton *QButtonGroup::button(int id) const;
     \since 4.1
 
     Returns the button with the specified \a id, or 0 if no such button
     exists.
 */
+QAbstractButton *QButtonGroup::button(int id) const
+{
+    Q_D(const QButtonGroup);
+    return d->mapping.key(id);
+}
 
 /*!
-    \fn void QButtonGroup::setId(QAbstractButton *button, int id)
     \since 4.1
 
     Sets the \a id for the specified \a button. Note that \a id cannot
@@ -246,9 +324,14 @@
 
     \sa id()
 */
+void QButtonGroup::setId(QAbstractButton *button, int id)
+{
+    Q_D(QButtonGroup);
+    if (button && id != -1)
+        d->mapping[button] = id;
+}
 
 /*!
-    \fn int QButtonGroup::id(QAbstractButton *button) const;
     \since 4.1
 
     Returns the id for the specified \a button, or -1 if no such button
@@ -257,13 +340,27 @@
 
     \sa setId()
 */
+int QButtonGroup::id(QAbstractButton *button) const
+{
+    Q_D(const QButtonGroup);
+    return d->mapping.value(button, -1);
+}
 
 /*!
-    \fn int QButtonGroup::checkedId() const;
     \since 4.1
 
     Returns the id of the checkedButton(), or -1 if no button is checked.
 
     \sa setId()
 */
+int QButtonGroup::checkedId() const
+{
+    Q_D(const QButtonGroup);
+    return d->mapping.value(d->checkedButton, -1);
+}
 
+QT_END_NAMESPACE
+
+#include "moc_qbuttongroup.cpp"
+
+#endif // QT_NO_BUTTONGROUP
diff --git a/src/widgets/widgets/qbuttongroup_p.h b/src/widgets/widgets/qbuttongroup_p.h
new file mode 100644
index 00000000000..01c03678767
--- /dev/null
+++ b/src/widgets/widgets/qbuttongroup_p.h
@@ -0,0 +1,80 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the QtWidgets module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QBUTTONGROUP_P_H
+#define QBUTTONGROUP_P_H
+
+//
+//  W A R N I N G
+//  -------------
+//
+// This file is not part of the Qt API.  It exists purely as an
+// implementation detail.  This header file may change from version to
+// version without notice, or even be removed.
+//
+// We mean it.
+//
+
+#include <QtWidgets/qbuttongroup.h>
+
+#ifndef QT_NO_BUTTONGROUP
+
+#include <QtCore/private/qobject_p.h>
+
+#include <QtCore/qlist.h>
+#include <QtCore/qpointer.h>
+#include <QtCore/qhash.h>
+
+QT_BEGIN_NAMESPACE
+
+class QButtonGroupPrivate: public QObjectPrivate
+{
+    Q_DECLARE_PUBLIC(QButtonGroup)
+
+public:
+    QButtonGroupPrivate() : exclusive(true) {}
+
+    QList<QAbstractButton *> buttonList;
+    QPointer<QAbstractButton> checkedButton;
+    void detectCheckedButton();
+    void notifyChecked(QAbstractButton *button);
+
+    bool exclusive;
+    QHash<QAbstractButton*, int> mapping;
+};
+
+QT_END_NAMESPACE
+
+#endif // QT_NO_BUTTONGROUP
+
+#endif // QBUTTONGROUP_P_H
diff --git a/src/widgets/widgets/qcalendarwidget.cpp b/src/widgets/widgets/qcalendarwidget.cpp
index 913f1042873..66e4a89fe91 100644
--- a/src/widgets/widgets/qcalendarwidget.cpp
+++ b/src/widgets/widgets/qcalendarwidget.cpp
@@ -655,7 +655,6 @@ public:
     int dateEditAcceptDelay() const;
     void setDateEditAcceptDelay(int delay);
 
-    QDate date() const;
     void setDate(const QDate &date);
 
     bool eventFilter(QObject *o, QEvent *e) Q_DECL_OVERRIDE;
@@ -691,11 +690,6 @@ void QCalendarTextNavigator::setWidget(QWidget *widget)
     m_widget = widget;
 }
 
-QDate QCalendarTextNavigator::date() const
-{
-    return m_date;
-}
-
 void QCalendarTextNavigator::setDate(const QDate &date)
 {
     m_date = date;
diff --git a/src/widgets/widgets/qcheckbox.cpp b/src/widgets/widgets/qcheckbox.cpp
index ad2d019c4ad..19369d6cb16 100644
--- a/src/widgets/widgets/qcheckbox.cpp
+++ b/src/widgets/widgets/qcheckbox.cpp
@@ -390,3 +390,5 @@ bool QCheckBox::event(QEvent *e)
 
 
 QT_END_NAMESPACE
+
+#include "moc_qcheckbox.cpp"
diff --git a/src/widgets/widgets/qcombobox.cpp b/src/widgets/widgets/qcombobox.cpp
index 1cf75913026..08c8117e0ba 100644
--- a/src/widgets/widgets/qcombobox.cpp
+++ b/src/widgets/widgets/qcombobox.cpp
@@ -3440,5 +3440,6 @@ void QComboBox::setModelColumn(int visibleColumn)
 QT_END_NAMESPACE
 
 #include "moc_qcombobox.cpp"
+#include "moc_qcombobox_p.cpp"
 
 #endif // QT_NO_COMBOBOX
diff --git a/src/widgets/widgets/qcommandlinkbutton.cpp b/src/widgets/widgets/qcommandlinkbutton.cpp
index 4d43c999bfc..2ec8b1c41aa 100644
--- a/src/widgets/widgets/qcommandlinkbutton.cpp
+++ b/src/widgets/widgets/qcommandlinkbutton.cpp
@@ -413,3 +413,4 @@ QString QCommandLinkButton::description() const
 
 QT_END_NAMESPACE
 
+#include "moc_qcommandlinkbutton.cpp"
diff --git a/src/widgets/widgets/qdatetimeedit.cpp b/src/widgets/widgets/qdatetimeedit.cpp
index c3f9198598b..f72dc088da2 100644
--- a/src/widgets/widgets/qdatetimeedit.cpp
+++ b/src/widgets/widgets/qdatetimeedit.cpp
@@ -2692,5 +2692,6 @@ void QCalendarPopup::hideEvent(QHideEvent *)
 
 QT_END_NAMESPACE
 #include "moc_qdatetimeedit.cpp"
+#include "moc_qdatetimeedit_p.cpp"
 
 #endif // QT_NO_DATETIMEEDIT
diff --git a/src/widgets/widgets/qdial.cpp b/src/widgets/widgets/qdial.cpp
index 40c7e98726c..cee39e2ae3e 100644
--- a/src/widgets/widgets/qdial.cpp
+++ b/src/widgets/widgets/qdial.cpp
@@ -487,4 +487,6 @@ bool QDial::event(QEvent *e)
 
 QT_END_NAMESPACE
 
+#include "moc_qdial.cpp"
+
 #endif // QT_NO_DIAL
diff --git a/src/widgets/widgets/qdockwidget.cpp b/src/widgets/widgets/qdockwidget.cpp
index 03faca157fe..293a04ef884 100644
--- a/src/widgets/widgets/qdockwidget.cpp
+++ b/src/widgets/widgets/qdockwidget.cpp
@@ -1682,5 +1682,6 @@ QT_END_NAMESPACE
 
 #include "qdockwidget.moc"
 #include "moc_qdockwidget.cpp"
+#include "moc_qdockwidget_p.cpp"
 
 #endif // QT_NO_DOCKWIDGET
diff --git a/src/widgets/widgets/qfocusframe.cpp b/src/widgets/widgets/qfocusframe.cpp
index 6704631afce..8b8f4db86e8 100644
--- a/src/widgets/widgets/qfocusframe.cpp
+++ b/src/widgets/widgets/qfocusframe.cpp
@@ -339,3 +339,5 @@ bool QFocusFrame::event(QEvent *e)
 }
 
 QT_END_NAMESPACE
+
+#include "moc_qfocusframe.cpp"
diff --git a/src/widgets/widgets/qframe.cpp b/src/widgets/widgets/qframe.cpp
index 96a2e76713c..1661c5c881b 100644
--- a/src/widgets/widgets/qframe.cpp
+++ b/src/widgets/widgets/qframe.cpp
@@ -555,3 +555,5 @@ bool QFrame::event(QEvent *e)
 }
 
 QT_END_NAMESPACE
+
+#include "moc_qframe.cpp"
diff --git a/src/widgets/widgets/qkeysequenceedit.cpp b/src/widgets/widgets/qkeysequenceedit.cpp
index a663c4f8535..f8a3be366e6 100644
--- a/src/widgets/widgets/qkeysequenceedit.cpp
+++ b/src/widgets/widgets/qkeysequenceedit.cpp
@@ -324,3 +324,5 @@ void QKeySequenceEdit::timerEvent(QTimerEvent *e)
 #endif // QT_NO_KEYSEQUENCEEDIT
 
 QT_END_NAMESPACE
+
+#include "moc_qkeysequenceedit.cpp"
diff --git a/src/widgets/widgets/qlcdnumber.cpp b/src/widgets/widgets/qlcdnumber.cpp
index cc1fc203798..543a7aee116 100644
--- a/src/widgets/widgets/qlcdnumber.cpp
+++ b/src/widgets/widgets/qlcdnumber.cpp
@@ -1222,4 +1222,6 @@ bool QLCDNumber::event(QEvent *e)
 
 QT_END_NAMESPACE
 
+#include "moc_qlcdnumber.cpp"
+
 #endif // QT_NO_LCDNUMBER
diff --git a/src/widgets/widgets/qlineedit_p.cpp b/src/widgets/widgets/qlineedit_p.cpp
index b646e822093..b852b8991ce 100644
--- a/src/widgets/widgets/qlineedit_p.cpp
+++ b/src/widgets/widgets/qlineedit_p.cpp
@@ -553,4 +553,6 @@ int QLineEditPrivate::effectiveRightTextMargin() const
 
 QT_END_NAMESPACE
 
+#include "moc_qlineedit_p.cpp"
+
 #endif
diff --git a/src/widgets/widgets/qmainwindow.cpp b/src/widgets/widgets/qmainwindow.cpp
index 4ee22dc235c..f86244172dc 100644
--- a/src/widgets/widgets/qmainwindow.cpp
+++ b/src/widgets/widgets/qmainwindow.cpp
@@ -1746,4 +1746,6 @@ QMenu *QMainWindow::createPopupMenu()
 
 QT_END_NAMESPACE
 
+#include "moc_qmainwindow.cpp"
+
 #endif // QT_NO_MAINWINDOW
diff --git a/src/widgets/widgets/qmainwindowlayout.cpp b/src/widgets/widgets/qmainwindowlayout.cpp
index 63a6c718bc1..6c058877050 100644
--- a/src/widgets/widgets/qmainwindowlayout.cpp
+++ b/src/widgets/widgets/qmainwindowlayout.cpp
@@ -852,6 +852,25 @@ static QList<T> findChildrenHelper(const QObject *o)
     return result;
 }
 
+#ifndef QT_NO_DOCKWIDGET
+static QList<QDockWidget*> allMyDockWidgets(const QWidget *mainWindow)
+{
+    QList<QDockWidget*> result;
+    for (QObject *c : mainWindow->children()) {
+        if (auto *dw = qobject_cast<QDockWidget*>(c)) {
+            result.append(dw);
+        } else if (auto *gw = qobject_cast<QDockWidgetGroupWindow*>(c)) {
+            for (QObject *c : gw->children()) {
+                if (auto *dw = qobject_cast<QDockWidget*>(c))
+                    result.append(dw);
+            }
+        }
+    }
+
+    return result;
+}
+#endif // QT_NO_DOCKWIDGET
+
 //pre4.3 tests the format that was used before 4.3
 bool QMainWindowLayoutState::checkFormat(QDataStream &stream)
 {
@@ -875,9 +894,7 @@ bool QMainWindowLayoutState::checkFormat(QDataStream &stream)
 #ifndef QT_NO_DOCKWIDGET
             case QDockAreaLayout::DockWidgetStateMarker:
                 {
-                    QList<QDockWidget *> dockWidgets = findChildrenHelper<QDockWidget*>(mainWindow);
-                    foreach (QDockWidgetGroupWindow *floating, findChildrenHelper<QDockWidgetGroupWindow*>(mainWindow))
-                        dockWidgets += findChildrenHelper<QDockWidget*>(floating);
+                    const auto dockWidgets = allMyDockWidgets(mainWindow);
                     if (!dockAreaLayout.restoreState(stream, dockWidgets, true /*testing*/)) {
                         return false;
                     }
@@ -889,9 +906,7 @@ bool QMainWindowLayoutState::checkFormat(QDataStream &stream)
                     QRect geom;
                     stream >> geom;
                     QDockAreaLayoutInfo info;
-                    QList<QDockWidget *> dockWidgets = findChildrenHelper<QDockWidget*>(mainWindow);
-                    foreach (QDockWidgetGroupWindow *floating, findChildrenHelper<QDockWidgetGroupWindow*>(mainWindow))
-                        dockWidgets += findChildrenHelper<QDockWidget*>(floating);
+                    auto dockWidgets = allMyDockWidgets(mainWindow);
                     if (!info.restoreState(stream, dockWidgets, true /* testing*/))
                         return false;
                 }
@@ -935,9 +950,7 @@ bool QMainWindowLayoutState::restoreState(QDataStream &_stream,
 #ifndef QT_NO_DOCKWIDGET
             case QDockAreaLayout::DockWidgetStateMarker:
                 {
-                    QList<QDockWidget *> dockWidgets = findChildrenHelper<QDockWidget*>(mainWindow);
-                    foreach (QDockWidgetGroupWindow *floating, findChildrenHelper<QDockWidgetGroupWindow*>(mainWindow))
-                        dockWidgets += findChildrenHelper<QDockWidget*>(floating);
+                    const auto dockWidgets = allMyDockWidgets(mainWindow);
                     if (!dockAreaLayout.restoreState(stream, dockWidgets))
                         return false;
 
@@ -961,9 +974,7 @@ bool QMainWindowLayoutState::restoreState(QDataStream &_stream,
 #ifndef QT_NO_TABBAR
             case QDockAreaLayout::FloatingDockWidgetTabMarker:
             {
-                QList<QDockWidget *> dockWidgets = findChildrenHelper<QDockWidget*>(mainWindow);
-                foreach (QDockWidgetGroupWindow *floating, findChildrenHelper<QDockWidgetGroupWindow*>(mainWindow))
-                    dockWidgets += findChildrenHelper<QDockWidget*>(floating);
+                auto dockWidgets = allMyDockWidgets(mainWindow);
                 QDockWidgetGroupWindow* floatingTab = qt_mainwindow_layout(mainWindow)->createTabbedDockWindow();
                 *floatingTab->layoutInfo() = QDockAreaLayoutInfo(&dockAreaLayout.sep, QInternal::LeftDock,
                                                                  Qt::Horizontal, QTabBar::RoundedSouth, mainWindow);
@@ -2593,4 +2604,6 @@ void QMainWindowLayout::timerEvent(QTimerEvent *e)
 
 QT_END_NAMESPACE
 
+#include "moc_qmainwindowlayout_p.cpp"
+
 #endif // QT_NO_MAINWINDOW
diff --git a/src/widgets/widgets/qmenu.cpp b/src/widgets/widgets/qmenu.cpp
index 1b9e31968a6..274570b22a7 100644
--- a/src/widgets/widgets/qmenu.cpp
+++ b/src/widgets/widgets/qmenu.cpp
@@ -1948,7 +1948,7 @@ bool QMenu::isTearOffEnabled() const
   contents in a new window. When the menu is in this mode and the menu
   is visible returns \c true; otherwise false.
 
-  \sa hideTearOffMenu(), isTearOffEnabled()
+  \sa showTearOffMenu(), hideTearOffMenu(), isTearOffEnabled()
 */
 bool QMenu::isTearOffMenuVisible() const
 {
@@ -1958,15 +1958,54 @@ bool QMenu::isTearOffMenuVisible() const
 }
 
 /*!
-   This function will forcibly hide the torn off menu making it
-   disappear from the users desktop.
+   \since 5.7
 
-   \sa isTearOffMenuVisible(), isTearOffEnabled()
+   This function will forcibly show the torn off menu making it
+   appear on the user's desktop at the specified \e global position \a pos.
+
+   \sa hideTearOffMenu(), isTearOffMenuVisible(), isTearOffEnabled()
+*/
+void QMenu::showTearOffMenu(const QPoint &pos)
+{
+    Q_D(QMenu);
+    if (!d->tornPopup)
+        d->tornPopup = new QTornOffMenu(this);
+    const QSize &s = sizeHint();
+    d->tornPopup->setGeometry(pos.x(), pos.y(), s.width(), s.height());
+    d->tornPopup->show();
+}
+
+/*!
+   \overload
+   \since 5.7
+
+   This function will forcibly show the torn off menu making it
+   appear on the user's desktop under the mouse currsor.
+
+   \sa hideTearOffMenu(), isTearOffMenuVisible(), isTearOffEnabled()
+*/
+void QMenu::showTearOffMenu()
+{
+    showTearOffMenu(QCursor::pos());
+}
+
+/*!
+   This function will forcibly hide the torn off menu making it
+   disappear from the user's desktop.
+
+   \sa showTearOffMenu(), isTearOffMenuVisible(), isTearOffEnabled()
 */
 void QMenu::hideTearOffMenu()
 {
-    if (QWidget *w = d_func()->tornPopup)
-        w->close();
+    Q_D(QMenu);
+    if (d->tornPopup) {
+        d->tornPopup->close();
+        // QTornOffMenu sets WA_DeleteOnClose, so we
+        // should consider the torn-off menu deleted.
+        // This way showTearOffMenu() will not try to
+        // reuse the dying torn-off menu.
+        d->tornPopup = Q_NULLPTR;
+    }
 }
 
 
diff --git a/src/widgets/widgets/qmenu.h b/src/widgets/widgets/qmenu.h
index 6634082bda4..7dda38456af 100644
--- a/src/widgets/widgets/qmenu.h
+++ b/src/widgets/widgets/qmenu.h
@@ -171,6 +171,8 @@ public:
     bool isTearOffEnabled() const;
 
     bool isTearOffMenuVisible() const;
+    void showTearOffMenu();
+    void showTearOffMenu(const QPoint &pos);
     void hideTearOffMenu();
 
     void setDefaultAction(QAction *);
diff --git a/src/widgets/widgets/qmenubar.cpp b/src/widgets/widgets/qmenubar.cpp
index 261ff0bca3b..85d0c54357e 100644
--- a/src/widgets/widgets/qmenubar.cpp
+++ b/src/widgets/widgets/qmenubar.cpp
@@ -696,7 +696,8 @@ void QMenuBarPrivate::init()
     q->setSizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Minimum);
     q->setAttribute(Qt::WA_CustomWhatsThis);
 
-    platformMenuBar = QGuiApplicationPrivate::platformTheme()->createPlatformMenuBar();
+    if (!QApplication::instance()->testAttribute(Qt::AA_DontUseNativeMenuBar))
+        platformMenuBar = QGuiApplicationPrivate::platformTheme()->createPlatformMenuBar();
 
     if (platformMenuBar)
         q->hide();
@@ -1209,12 +1210,19 @@ void QMenuBar::leaveEvent(QEvent *)
         d->setCurrentAction(0);
 }
 
-QPlatformMenu *getPlatformMenu(QAction *action)
+QPlatformMenu *QMenuBarPrivate::getPlatformMenu(QAction *action)
 {
     if (!action || !action->menu())
         return 0;
 
-    return action->menu()->platformMenu();
+    QPlatformMenu *platformMenu = action->menu()->platformMenu();
+    if (!platformMenu && platformMenuBar) {
+        platformMenu = platformMenuBar->createMenu();
+        if (platformMenu)
+            action->menu()->setPlatformMenu(platformMenu);
+    }
+
+    return platformMenu;
 }
 
 /*!
@@ -1235,14 +1243,14 @@ void QMenuBar::actionEvent(QActionEvent *e)
             return;
 
         if (e->type() == QEvent::ActionAdded) {
-            QPlatformMenu *menu = getPlatformMenu(e->action());
+            QPlatformMenu *menu = d->getPlatformMenu(e->action());
             if (menu) {
                 QPlatformMenu* beforeMenu = NULL;
                 for (int beforeIndex = d->indexOf(e->action()) + 1;
                      !beforeMenu && (beforeIndex < actions().size());
                      ++beforeIndex)
                 {
-                    beforeMenu = getPlatformMenu(actions().at(beforeIndex));
+                    beforeMenu = d->getPlatformMenu(actions().at(beforeIndex));
                 }
 
                 menu->setTag(reinterpret_cast<quintptr>(e->action()));
@@ -1250,12 +1258,12 @@ void QMenuBar::actionEvent(QActionEvent *e)
                 d->platformMenuBar->insertMenu(menu, beforeMenu);
             }
         } else if (e->type() == QEvent::ActionRemoved) {
-            QPlatformMenu *menu = getPlatformMenu(e->action());
+            QPlatformMenu *menu = d->getPlatformMenu(e->action());
             if (menu)
                 d->platformMenuBar->removeMenu(menu);
         } else if (e->type() == QEvent::ActionChanged) {
             QPlatformMenu* cur = d->platformMenuBar->menuForTag(reinterpret_cast<quintptr>(e->action()));
-            QPlatformMenu *menu = getPlatformMenu(e->action());
+            QPlatformMenu *menu = d->getPlatformMenu(e->action());
 
             // the menu associated with the action can change, need to
             // remove and/or insert the new platform menu
@@ -1270,7 +1278,7 @@ void QMenuBar::actionEvent(QActionEvent *e)
                          !beforeMenu && (beforeIndex < actions().size());
                          ++beforeIndex)
                     {
-                        beforeMenu = getPlatformMenu(actions().at(beforeIndex));
+                        beforeMenu = d->getPlatformMenu(actions().at(beforeIndex));
                     }
                     d->platformMenuBar->insertMenu(menu, beforeMenu);
                 }
diff --git a/src/widgets/widgets/qmenubar_p.h b/src/widgets/widgets/qmenubar_p.h
index 04f608d22f5..05b1878c209 100644
--- a/src/widgets/widgets/qmenubar_p.h
+++ b/src/widgets/widgets/qmenubar_p.h
@@ -143,6 +143,7 @@ public:
 
     QBasicTimer autoReleaseTimer;
     QPlatformMenuBar *platformMenuBar;
+    QPlatformMenu *getPlatformMenu(QAction *action);
 
     inline int indexOf(QAction *act) const { return q_func()->actions().indexOf(act); }
 
diff --git a/src/widgets/widgets/qprogressbar.cpp b/src/widgets/widgets/qprogressbar.cpp
index 2897929a143..1ba0d78622b 100644
--- a/src/widgets/widgets/qprogressbar.cpp
+++ b/src/widgets/widgets/qprogressbar.cpp
@@ -629,4 +629,6 @@ QString QProgressBar::format() const
 
 QT_END_NAMESPACE
 
+#include "moc_qprogressbar.cpp"
+
 #endif // QT_NO_PROGRESSBAR
diff --git a/src/widgets/widgets/qradiobutton.cpp b/src/widgets/widgets/qradiobutton.cpp
index 125182f79f7..55a584078a4 100644
--- a/src/widgets/widgets/qradiobutton.cpp
+++ b/src/widgets/widgets/qradiobutton.cpp
@@ -269,3 +269,5 @@ bool QRadioButton::event(QEvent *e)
 
 
 QT_END_NAMESPACE
+
+#include "moc_qradiobutton.cpp"
diff --git a/src/widgets/widgets/qrubberband.cpp b/src/widgets/widgets/qrubberband.cpp
index 048817d07b7..13aa66dec7c 100644
--- a/src/widgets/widgets/qrubberband.cpp
+++ b/src/widgets/widgets/qrubberband.cpp
@@ -333,4 +333,6 @@ bool QRubberBand::event(QEvent *e)
 
 QT_END_NAMESPACE
 
+#include "moc_qrubberband.cpp"
+
 #endif // QT_NO_RUBBERBAND
diff --git a/src/widgets/widgets/qscrollarea.cpp b/src/widgets/widgets/qscrollarea.cpp
index bd070405095..0868dcbd690 100644
--- a/src/widgets/widgets/qscrollarea.cpp
+++ b/src/widgets/widgets/qscrollarea.cpp
@@ -538,4 +538,6 @@ Qt::Alignment QScrollArea::alignment() const
 
 QT_END_NAMESPACE
 
+#include "moc_qscrollarea.cpp"
+
 #endif // QT_NO_SCROLLAREA
diff --git a/src/widgets/widgets/qscrollbar.cpp b/src/widgets/widgets/qscrollbar.cpp
index 7399601c2ed..7dd41f6a0c1 100644
--- a/src/widgets/widgets/qscrollbar.cpp
+++ b/src/widgets/widgets/qscrollbar.cpp
@@ -744,4 +744,6 @@ Q_WIDGETS_EXPORT QStyleOptionSlider qt_qscrollbarStyleOption(QScrollBar *scrollb
 
 QT_END_NAMESPACE
 
+#include "moc_qscrollbar.cpp"
+
 #endif // QT_NO_SCROLLBAR
diff --git a/src/widgets/widgets/qslider.cpp b/src/widgets/widgets/qslider.cpp
index bf27b19940a..7b675fccbd8 100644
--- a/src/widgets/widgets/qslider.cpp
+++ b/src/widgets/widgets/qslider.cpp
@@ -559,3 +559,5 @@ Q_WIDGETS_EXPORT QStyleOptionSlider qt_qsliderStyleOption(QSlider *slider)
 #endif
 
 QT_END_NAMESPACE
+
+#include "moc_qslider.cpp"
diff --git a/src/widgets/widgets/qspinbox.cpp b/src/widgets/widgets/qspinbox.cpp
index 68b405cc5e4..a5c096c3a80 100644
--- a/src/widgets/widgets/qspinbox.cpp
+++ b/src/widgets/widgets/qspinbox.cpp
@@ -1328,4 +1328,6 @@ bool QSpinBox::event(QEvent *event)
 
 QT_END_NAMESPACE
 
+#include "moc_qspinbox.cpp"
+
 #endif // QT_NO_SPINBOX
diff --git a/src/widgets/widgets/qsplashscreen.cpp b/src/widgets/widgets/qsplashscreen.cpp
index b379e01b0a2..4ad2b83582e 100644
--- a/src/widgets/widgets/qsplashscreen.cpp
+++ b/src/widgets/widgets/qsplashscreen.cpp
@@ -358,4 +358,6 @@ bool QSplashScreen::event(QEvent *e)
 
 QT_END_NAMESPACE
 
+#include "moc_qsplashscreen.cpp"
+
 #endif //QT_NO_SPLASHSCREEN
diff --git a/src/widgets/widgets/qsplitter.cpp b/src/widgets/widgets/qsplitter.cpp
index 9ebd232bef8..e3ca6b0a79b 100644
--- a/src/widgets/widgets/qsplitter.cpp
+++ b/src/widgets/widgets/qsplitter.cpp
@@ -1739,4 +1739,6 @@ QTextStream& operator>>(QTextStream& ts, QSplitter& splitter)
 
 QT_END_NAMESPACE
 
+#include "moc_qsplitter.cpp"
+
 #endif // QT_NO_SPLITTER
diff --git a/src/widgets/widgets/qstackedwidget.cpp b/src/widgets/widgets/qstackedwidget.cpp
index 097f98fd71c..38ce182fbf7 100644
--- a/src/widgets/widgets/qstackedwidget.cpp
+++ b/src/widgets/widgets/qstackedwidget.cpp
@@ -293,4 +293,6 @@ bool QStackedWidget::event(QEvent *e)
 
 QT_END_NAMESPACE
 
+#include "moc_qstackedwidget.cpp"
+
 #endif // QT_NO_STACKEDWIDGET
diff --git a/src/widgets/widgets/qstatusbar.cpp b/src/widgets/widgets/qstatusbar.cpp
index 2e1cd29839e..7de1d92acfa 100644
--- a/src/widgets/widgets/qstatusbar.cpp
+++ b/src/widgets/widgets/qstatusbar.cpp
@@ -789,4 +789,6 @@ bool QStatusBar::event(QEvent *e)
 
 QT_END_NAMESPACE
 
+#include "moc_qstatusbar.cpp"
+
 #endif
diff --git a/src/widgets/widgets/qtabbar.cpp b/src/widgets/widgets/qtabbar.cpp
index ba3fc2fcd7f..f56830c14b9 100644
--- a/src/widgets/widgets/qtabbar.cpp
+++ b/src/widgets/widgets/qtabbar.cpp
@@ -2583,4 +2583,4 @@ QT_END_NAMESPACE
 
 #endif // QT_NO_TABBAR
 
-
+#include "moc_qtabbar_p.cpp"
diff --git a/src/widgets/widgets/qtoolbarextension.cpp b/src/widgets/widgets/qtoolbarextension.cpp
index 71061c81025..267e220b8ff 100644
--- a/src/widgets/widgets/qtoolbarextension.cpp
+++ b/src/widgets/widgets/qtoolbarextension.cpp
@@ -87,4 +87,6 @@ QSize QToolBarExtension::sizeHint() const
 
 QT_END_NAMESPACE
 
+#include "moc_qtoolbarextension_p.cpp"
+
 #endif // QT_NO_TOOLBUTTON
diff --git a/src/widgets/widgets/qtoolbarextension_p.h b/src/widgets/widgets/qtoolbarextension_p.h
index e8725d77b82..ea159ce986c 100644
--- a/src/widgets/widgets/qtoolbarextension_p.h
+++ b/src/widgets/widgets/qtoolbarextension_p.h
@@ -60,7 +60,6 @@ QT_BEGIN_NAMESPACE
 class Q_AUTOTEST_EXPORT QToolBarExtension : public QToolButton
 {
     Q_OBJECT
-    Qt::Orientation orientation;
 
 public:
     explicit QToolBarExtension(QWidget *parent);
diff --git a/src/widgets/widgets/qtoolbarlayout.cpp b/src/widgets/widgets/qtoolbarlayout.cpp
index 2d7ab68dde7..79174bdbff0 100644
--- a/src/widgets/widgets/qtoolbarlayout.cpp
+++ b/src/widgets/widgets/qtoolbarlayout.cpp
@@ -748,4 +748,6 @@ QToolBarItem *QToolBarLayout::createItem(QAction *action)
 
 QT_END_NAMESPACE
 
+#include "moc_qtoolbarlayout_p.cpp"
+
 #endif // QT_NO_TOOLBAR
diff --git a/src/widgets/widgets/qtoolbarseparator.cpp b/src/widgets/widgets/qtoolbarseparator.cpp
index 57997556a53..c99a8bcc4c4 100644
--- a/src/widgets/widgets/qtoolbarseparator.cpp
+++ b/src/widgets/widgets/qtoolbarseparator.cpp
@@ -86,4 +86,6 @@ void QToolBarSeparator::paintEvent(QPaintEvent *)
 
 QT_END_NAMESPACE
 
+#include "moc_qtoolbarseparator_p.cpp"
+
 #endif // QT_NO_TOOLBAR
diff --git a/src/widgets/widgets/qwidgetanimator.cpp b/src/widgets/widgets/qwidgetanimator.cpp
index edf0b32ba02..d46d65546cf 100644
--- a/src/widgets/widgets/qwidgetanimator.cpp
+++ b/src/widgets/widgets/qwidgetanimator.cpp
@@ -120,3 +120,5 @@ bool QWidgetAnimator::animating() const
 }
 
 QT_END_NAMESPACE
+
+#include "moc_qwidgetanimator_p.cpp"
diff --git a/src/widgets/widgets/qwidgetlinecontrol.cpp b/src/widgets/widgets/qwidgetlinecontrol.cpp
index f9674668ec6..a77794df8a1 100644
--- a/src/widgets/widgets/qwidgetlinecontrol.cpp
+++ b/src/widgets/widgets/qwidgetlinecontrol.cpp
@@ -1924,4 +1924,6 @@ bool QWidgetLineControl::isRedoAvailable() const
 
 QT_END_NAMESPACE
 
+#include "moc_qwidgetlinecontrol_p.cpp"
+
 #endif
diff --git a/src/widgets/widgets/qwidgetresizehandler.cpp b/src/widgets/widgets/qwidgetresizehandler.cpp
index 11bfc38b0dd..2a7b1eeeccd 100644
--- a/src/widgets/widgets/qwidgetresizehandler.cpp
+++ b/src/widgets/widgets/qwidgetresizehandler.cpp
@@ -541,4 +541,6 @@ void QWidgetResizeHandler::doMove()
 
 QT_END_NAMESPACE
 
+#include "moc_qwidgetresizehandler_p.cpp"
+
 #endif //QT_NO_RESIZEHANDLER
diff --git a/src/widgets/widgets/widgets.pri b/src/widgets/widgets/widgets.pri
index c31a7f76824..784055ed62e 100644
--- a/src/widgets/widgets/widgets.pri
+++ b/src/widgets/widgets/widgets.pri
@@ -2,6 +2,7 @@
 
 HEADERS += \
         widgets/qbuttongroup.h \
+        widgets/qbuttongroup_p.h \
         widgets/qabstractbutton.h \
         widgets/qabstractbutton_p.h \
         widgets/qabstractslider.h \
@@ -84,6 +85,7 @@ HEADERS += \
         widgets/qplaintextedit_p.h
 
 SOURCES += \
+        widgets/qbuttongroup.cpp \
         widgets/qabstractbutton.cpp \
         widgets/qabstractslider.cpp \
         widgets/qabstractspinbox.cpp \
diff --git a/src/xml/xml.pro b/src/xml/xml.pro
index 57bf11e5aa2..f281e35444e 100644
--- a/src/xml/xml.pro
+++ b/src/xml/xml.pro
@@ -6,11 +6,11 @@ win32-msvc*|win32-icc:QMAKE_LFLAGS += /BASE:0x61000000
 
 QMAKE_DOCS = $$PWD/doc/qtxml.qdocconf
 
-load(qt_module)
-
 HEADERS += qtxmlglobal.h
 
 PRECOMPILED_HEADER =
 
 include(dom/dom.pri)
 include(sax/sax.pri)
+
+load(qt_module)
diff --git a/tests/auto/cmake/CMakeLists.txt b/tests/auto/cmake/CMakeLists.txt
index 5248f75a84a..1abbef0d68d 100644
--- a/tests/auto/cmake/CMakeLists.txt
+++ b/tests/auto/cmake/CMakeLists.txt
@@ -68,6 +68,24 @@ expect_fail(test_wrap_cpp_options)
 expect_pass(test_platform_defs_include)
 expect_pass(test_qtmainwin_library)
 
+if (HAVE_NINJA)
+    make_directory("${CMAKE_CURRENT_SOURCE_DIR}/test_QFINDTESTDATA/build")
+    add_test(test_QFINDTESTDATA ${CMAKE_CTEST_COMMAND}
+      --build-and-test
+      "${CMAKE_CURRENT_SOURCE_DIR}/test_QFINDTESTDATA"
+      # Build in a subdir of the source dir.
+      # This causes Ninja to use relative paths.
+      "${CMAKE_CURRENT_SOURCE_DIR}/test_QFINDTESTDATA/build"
+      --build-generator Ninja
+      --build-options "-DCMAKE_PREFIX_PATH=${CMAKE_PREFIX_PATH}"
+    )
+    add_test(NAME run_test_QFINDTESTDATA COMMAND sh -c "cd \"${CMAKE_SOURCE_DIR}/test_QFINDTESTDATA/build/tests\" && ./test_QFINDTESTDATA -v2")
+
+    set_property(TEST run_test_QFINDTESTDATA
+        PROPERTY DEPENDS test_QFINDTESTDATA
+    )
+endif()
+
 if (NOT NO_DBUS)
     expect_pass(test_dbus_module)
 endif()
diff --git a/tests/auto/cmake/test_QFINDTESTDATA/CMakeLists.txt b/tests/auto/cmake/test_QFINDTESTDATA/CMakeLists.txt
new file mode 100644
index 00000000000..e56c3c5eb9d
--- /dev/null
+++ b/tests/auto/cmake/test_QFINDTESTDATA/CMakeLists.txt
@@ -0,0 +1,11 @@
+
+cmake_minimum_required(VERSION 2.8.11)
+
+project(test_QFINDTESTDATA)
+
+find_package(Qt5Test REQUIRED)
+
+set(CMAKE_AUTOMOC ON)
+set(CMAKE_INCLUDE_CURRENT_DIR ON)
+
+add_subdirectory(tests)
diff --git a/tests/auto/cmake/test_QFINDTESTDATA/tests/CMakeLists.txt b/tests/auto/cmake/test_QFINDTESTDATA/tests/CMakeLists.txt
new file mode 100644
index 00000000000..dfe321982a9
--- /dev/null
+++ b/tests/auto/cmake/test_QFINDTESTDATA/tests/CMakeLists.txt
@@ -0,0 +1,4 @@
+
+add_executable(test_QFINDTESTDATA WIN32 main.cpp)
+
+target_link_libraries(test_QFINDTESTDATA Qt5::Test)
diff --git a/tests/auto/cmake/test_QFINDTESTDATA/tests/main.cpp b/tests/auto/cmake/test_QFINDTESTDATA/tests/main.cpp
new file mode 100644
index 00000000000..0a5b6acd323
--- /dev/null
+++ b/tests/auto/cmake/test_QFINDTESTDATA/tests/main.cpp
@@ -0,0 +1,55 @@
+/****************************************************************************
+**
+** Copyright (C) 2016 Stephen Kelly <steveire@gmail,com>
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QCoreApplication>
+#include <QtTest/QTest>
+
+class TestClass : public QObject
+{
+  Q_OBJECT
+public:
+  TestClass(QObject* parent = 0) {}
+
+private slots:
+  void doTest();
+};
+
+void TestClass::doTest()
+{
+    QFile f(QFINDTESTDATA("testdata.txt"));
+    QVERIFY(f.open(QFile::ReadOnly));
+    QCOMPARE(f.readAll().trimmed(), QByteArrayLiteral("This is a test."));
+}
+
+QTEST_MAIN(TestClass)
+#include "main.moc"
diff --git a/tests/auto/cmake/test_QFINDTESTDATA/tests/testdata.txt b/tests/auto/cmake/test_QFINDTESTDATA/tests/testdata.txt
new file mode 100644
index 00000000000..484ba93ef5b
--- /dev/null
+++ b/tests/auto/cmake/test_QFINDTESTDATA/tests/testdata.txt
@@ -0,0 +1 @@
+This is a test.
diff --git a/tests/auto/corelib/global/qglobal/tst_qglobal.cpp b/tests/auto/corelib/global/qglobal/tst_qglobal.cpp
index 152906287c3..bb4d1f4bf2d 100644
--- a/tests/auto/corelib/global/qglobal/tst_qglobal.cpp
+++ b/tests/auto/corelib/global/qglobal/tst_qglobal.cpp
@@ -732,8 +732,8 @@ void tst_QGlobal::testqOverload()
     QVERIFY(qOverload<QByteArray>(&freeOverloaded) ==
              static_cast<void (*)(QByteArray)>(&freeOverloaded));
 
-    QVERIFY((qOverload<QByteArray, const QString &>(&freeOverloaded)),
-             static_cast<void (*)(QByteArray, const QString &)>(&freeOverloaded));
+    QVERIFY((qOverload<QByteArray, const QString &>(&freeOverloaded) ==
+             static_cast<void (*)(QByteArray, const QString &)>(&freeOverloaded)));
 
     // value returning free overloaded functions
     QVERIFY(qOverload<>(&freeOverloadedGet) ==
diff --git a/tests/auto/corelib/io/qprocess/tst_qprocess.cpp b/tests/auto/corelib/io/qprocess/tst_qprocess.cpp
index e5195000aab..c47e88b0e6b 100644
--- a/tests/auto/corelib/io/qprocess/tst_qprocess.cpp
+++ b/tests/auto/corelib/io/qprocess/tst_qprocess.cpp
@@ -141,6 +141,8 @@ private slots:
     void startStopStartStop();
     void startStopStartStopBuffers_data();
     void startStopStartStopBuffers();
+    void processEventsInAReadyReadSlot_data();
+    void processEventsInAReadyReadSlot();
 
     // keep these at the end, since they use lots of processes and sometimes
     // caused obscure failures to occur in tests that followed them (esp. on the Mac)
@@ -153,6 +155,7 @@ private slots:
 protected slots:
     void readFromProcess();
     void exitLoopSlot();
+    void processApplicationEvents();
 #ifndef Q_OS_WINCE
     void restartProcess();
     void waitForReadyReadInAReadyReadSlotSlot();
@@ -471,6 +474,11 @@ void tst_QProcess::exitLoopSlot()
     QTestEventLoop::instance().exitLoop();
 }
 
+void tst_QProcess::processApplicationEvents()
+{
+    QCoreApplication::processEvents();
+}
+
 #ifndef Q_OS_WINCE
 // Reading and writing to a process is not supported on Qt/CE
 void tst_QProcess::echoTest2()
@@ -688,11 +696,7 @@ void tst_QProcess::waitForFinished()
 
     process.start("testProcessOutput/testProcessOutput");
 
-#if !defined(Q_OS_WINCE)
-    QVERIFY(process.waitForFinished(5000));
-#else
-    QVERIFY(process.waitForFinished(30000));
-#endif
+    QVERIFY(process.waitForFinished());
     QCOMPARE(process.exitStatus(), QProcess::NormalExit);
 
 #if defined (Q_OS_WINCE)
@@ -916,12 +920,7 @@ void tst_QProcess::hardExit()
     proc.start("testProcessEcho/testProcessEcho");
 #endif
 
-#ifndef Q_OS_WINCE
-    QVERIFY(proc.waitForStarted(5000));
-#else
-    QVERIFY(proc.waitForStarted(10000));
-#endif
-
+    QVERIFY2(proc.waitForStarted(), qPrintable(proc.errorString()));
     proc.kill();
 
     QVERIFY(proc.waitForFinished(5000));
@@ -1417,24 +1416,17 @@ void tst_QProcess::spaceArgsTest()
         QString program = programs.at(i);
         process.start(program, args);
 
-#if defined(Q_OS_WINCE)
-        const int timeOutMS = 10000;
-#else
-        const int timeOutMS = 5000;
-#endif
         QByteArray errorMessage;
-        bool started = process.waitForStarted(timeOutMS);
+        bool started = process.waitForStarted();
         if (!started)
             errorMessage = startFailMessage(program, process);
         QVERIFY2(started, errorMessage.constData());
-        QVERIFY(process.waitForFinished(timeOutMS));
+        QVERIFY(process.waitForFinished());
         QCOMPARE(process.exitStatus(), QProcess::NormalExit);
         QCOMPARE(process.exitCode(), 0);
 
 #if !defined(Q_OS_WINCE)
         QStringList actual = QString::fromLatin1(process.readAll()).split("|");
-#endif
-#if !defined(Q_OS_WINCE)
         QVERIFY(!actual.isEmpty());
         // not interested in the program name, it might be different.
         actual.removeFirst();
@@ -1459,8 +1451,6 @@ void tst_QProcess::spaceArgsTest()
 
 #if !defined(Q_OS_WINCE)
         actual = QString::fromLatin1(process.readAll()).split("|");
-#endif
-#if !defined(Q_OS_WINCE)
         QVERIFY(!actual.isEmpty());
         // not interested in the program name, it might be different.
         actual.removeFirst();
@@ -1482,13 +1472,8 @@ void tst_QProcess::nativeArguments()
 
     proc.start(QString::fromLatin1("testProcessSpacesArgs/nospace"), QStringList());
 
-#if !defined(Q_OS_WINCE)
-    QVERIFY(proc.waitForStarted(5000));
-    QVERIFY(proc.waitForFinished(5000));
-#else
-    QVERIFY(proc.waitForStarted(10000));
-    QVERIFY(proc.waitForFinished(10000));
-#endif
+    QVERIFY2(proc.waitForStarted(), qPrintable(proc.errorString()));
+    QVERIFY(proc.waitForFinished());
     QCOMPARE(proc.exitStatus(), QProcess::NormalExit);
     QCOMPARE(proc.exitCode(), 0);
 
@@ -2550,6 +2535,31 @@ void tst_QProcess::startStopStartStopBuffers()
     }
 }
 
+void tst_QProcess::processEventsInAReadyReadSlot_data()
+{
+    QTest::addColumn<bool>("callWaitForReadyRead");
+
+    QTest::newRow("no waitForReadyRead") << false;
+    QTest::newRow("waitForReadyRead") << true;
+}
+
+void tst_QProcess::processEventsInAReadyReadSlot()
+{
+    // Test whether processing events in a readyReadXXX slot crashes. (QTBUG-48697)
+    QFETCH(bool, callWaitForReadyRead);
+    QProcess process;
+    QObject::connect(&process, &QProcess::readyReadStandardOutput,
+                     this, &tst_QProcess::processApplicationEvents);
+    process.start("testProcessEcho/testProcessEcho");
+    QVERIFY(process.waitForStarted());
+    const QByteArray data(156, 'x');
+    process.write(data.constData(), data.size() + 1);
+    if (callWaitForReadyRead)
+        QVERIFY(process.waitForReadyRead());
+    if (process.state() == QProcess::Running)
+        QVERIFY(process.waitForFinished());
+}
+
 #endif //QT_NO_PROCESS
 
 QTEST_MAIN(tst_QProcess)
diff --git a/tests/auto/corelib/io/qtextstream/test/test.pro b/tests/auto/corelib/io/qtextstream/test/test.pro
index 93fb6d232fd..50335524d37 100644
--- a/tests/auto/corelib/io/qtextstream/test/test.pro
+++ b/tests/auto/corelib/io/qtextstream/test/test.pro
@@ -19,3 +19,7 @@ TESTDATA += \
     ../qtextstream.qrc \
     ../tst_qtextstream.cpp \
     ../resources
+
+builtin_testdata {
+    DEFINES += BUILTIN_TESTDATA
+}
diff --git a/tests/auto/corelib/io/qtextstream/tst_qtextstream.cpp b/tests/auto/corelib/io/qtextstream/tst_qtextstream.cpp
index 439da8b1a37..104873b85e3 100644
--- a/tests/auto/corelib/io/qtextstream/tst_qtextstream.cpp
+++ b/tests/auto/corelib/io/qtextstream/tst_qtextstream.cpp
@@ -60,6 +60,7 @@ public:
 public slots:
     void initTestCase();
     void cleanup();
+    void cleanupTestCase();
 
 private slots:
     void getSetCheck();
@@ -223,6 +224,8 @@ private slots:
     void alignAccountingStyle();
     void setCodec();
 
+    void textModeOnEmptyRead();
+
 private:
     void generateLineData(bool for_QString);
     void generateAllData(bool for_QString);
@@ -234,6 +237,9 @@ private:
 
     QTemporaryDir tempDir;
     QString testFileName;
+#ifdef BUILTIN_TESTDATA
+    QSharedPointer<QTemporaryDir> m_dataDir;
+#endif
     const QString m_rfc3261FilePath;
     const QString m_shiftJisFilePath;
 };
@@ -260,9 +266,14 @@ void tst_QTextStream::initTestCase()
 
     testFileName = tempDir.path() + "/testfile";
 
+#ifdef BUILTIN_TESTDATA
+    m_dataDir = QEXTRACTTESTDATA("/");
+    QVERIFY2(QDir::setCurrent(m_dataDir->path()), qPrintable("Could not chdir to " + m_dataDir->path()));
+#else
     // chdir into the testdata dir and refer to our helper apps with relative paths
     QString testdata_dir = QFileInfo(QFINDTESTDATA("stdinProcess")).absolutePath();
     QVERIFY2(QDir::setCurrent(testdata_dir), qPrintable("Could not chdir to " + testdata_dir));
+#endif
 }
 
 // Testing get/set functions
@@ -385,6 +396,13 @@ void tst_QTextStream::cleanup()
     QCoreApplication::instance()->processEvents();
 }
 
+void tst_QTextStream::cleanupTestCase()
+{
+#ifdef BUILTIN_TESTDATA
+    QDir::setCurrent(QCoreApplication::applicationDirPath());
+#endif
+}
+
 // ------------------------------------------------------------------------------
 void tst_QTextStream::construction()
 {
@@ -3040,6 +3058,19 @@ void tst_QTextStream::int_write_with_locale()
     QCOMPARE(result, output);
 }
 
+void tst_QTextStream::textModeOnEmptyRead()
+{
+    const QString filename(tempDir.path() + QLatin1String("/textmodetest.txt"));
+
+    QFile file(filename);
+    QVERIFY2(file.open(QIODevice::ReadWrite | QIODevice::Text), qPrintable(file.errorString()));
+    QTextStream stream(&file);
+    QVERIFY(file.isTextModeEnabled());
+    QString emptyLine = stream.readLine(); // Text mode flag cleared here
+    QVERIFY(file.isTextModeEnabled());
+}
+
+
 // ------------------------------------------------------------------------------
 
 QTEST_MAIN(tst_QTextStream)
diff --git a/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp b/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
index 2f954e16cf3..fd32dc1ef84 100644
--- a/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
+++ b/tests/auto/corelib/kernel/qmetaobject/tst_qmetaobject.cpp
@@ -131,6 +131,22 @@ namespace MyNamespace {
         MyEnum m_enum;
         MyFlags m_flags;
     };
+
+    // Test inherits
+    class MyClassSubclass : public MyClass
+    {
+        Q_OBJECT
+    };
+
+    class MyClassSubclass2 : public MyClass2
+    {
+        Q_OBJECT
+    };
+
+    class MyClass2Subclass : public MyClass
+    {
+        Q_OBJECT
+    };
 }
 
 
@@ -222,6 +238,9 @@ private slots:
     void signalIndex();
     void enumDebugStream();
 
+    void inherits_data();
+    void inherits();
+
 signals:
     void value6Changed();
     void value7Changed(const QString &);
@@ -1425,5 +1444,34 @@ void tst_QMetaObject::enumDebugStream()
     qDebug() << f1 << f2;
 }
 
+void tst_QMetaObject::inherits_data()
+{
+    QTest::addColumn<const QMetaObject *>("derivedMetaObject");
+    QTest::addColumn<const QMetaObject *>("baseMetaObject");
+    QTest::addColumn<bool>("inheritsResult");
+
+    QTest::newRow("MyClass inherits QObject")
+        << &MyNamespace::MyClass::staticMetaObject << &QObject::staticMetaObject << true;
+    QTest::newRow("QObject inherits MyClass")
+        << &QObject::staticMetaObject << &MyNamespace::MyClass::staticMetaObject << false;
+    QTest::newRow("MyClass inherits MyClass")
+        << &MyNamespace::MyClass::staticMetaObject << &MyNamespace::MyClass::staticMetaObject << true;
+    QTest::newRow("MyClassSubclass inherits QObject")
+        << &MyNamespace::MyClassSubclass::staticMetaObject << &QObject::staticMetaObject << true;
+    QTest::newRow("MyClassSubclass2 inherits QObject")
+        << &MyNamespace::MyClassSubclass2::staticMetaObject << &QObject::staticMetaObject << true;
+    QTest::newRow("MyClassSubclass2 inherits MyClass2")
+        << &MyNamespace::MyClassSubclass2::staticMetaObject << &MyNamespace::MyClass2Subclass::staticMetaObject << false;
+}
+
+void tst_QMetaObject::inherits()
+{
+    QFETCH(const QMetaObject *, derivedMetaObject);
+    QFETCH(const QMetaObject *, baseMetaObject);
+    QFETCH(bool, inheritsResult);
+
+    QCOMPARE(derivedMetaObject->inherits(baseMetaObject), inheritsResult);
+}
+
 QTEST_MAIN(tst_QMetaObject)
 #include "tst_qmetaobject.moc"
diff --git a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
index b1ae4292d02..fbb6a309176 100644
--- a/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
+++ b/tests/auto/corelib/kernel/qmetatype/tst_qmetatype.cpp
@@ -1473,7 +1473,7 @@ static QByteArray createTypeName(const char *begin, const char *va)
     }
     if (tn.endsWith('>'))
         tn += ' ';
-        tn += ">";
+    tn += '>';
     return tn;
 }
 #endif
diff --git a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
index 540cd667155..23f8ff58577 100644
--- a/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
+++ b/tests/auto/corelib/kernel/qobject/tst_qobject.cpp
@@ -275,8 +275,10 @@ static void playWithObjects()
 
 void tst_QObject::initTestCase()
 {
+#ifndef QT_NO_PROCESS
     const QString testDataDir = QFileInfo(QFINDTESTDATA("signalbug")).absolutePath();
     QVERIFY2(QDir::setCurrent(testDataDir), qPrintable("Could not chdir to " + testDataDir));
+#endif
 }
 
 void tst_QObject::disconnect()
diff --git a/tests/auto/corelib/kernel/qsharedmemory/qsharedmemory.pro b/tests/auto/corelib/kernel/qsharedmemory/qsharedmemory.pro
index a36b15c9065..69062a97413 100644
--- a/tests/auto/corelib/kernel/qsharedmemory/qsharedmemory.pro
+++ b/tests/auto/corelib/kernel/qsharedmemory/qsharedmemory.pro
@@ -1,3 +1,5 @@
 TEMPLATE = subdirs
 
-SUBDIRS = sharedmemoryhelper test
+!winrt: SUBDIRS = sharedmemoryhelper
+
+SUBDIRS += test
diff --git a/tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp b/tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp
index a4c918ed230..b6f6d2a7f3f 100644
--- a/tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp
+++ b/tests/auto/corelib/kernel/qsharedmemory/test/tst_qsharedmemory.cpp
@@ -133,7 +133,9 @@ tst_QSharedMemory::~tst_QSharedMemory()
 
 void tst_QSharedMemory::initTestCase()
 {
+#ifndef QT_NO_PROCESS
     QVERIFY2(!m_helperBinary.isEmpty(), "Could not find helper binary");
+#endif
 }
 
 void tst_QSharedMemory::init()
diff --git a/tests/auto/corelib/plugin/plugin.pro b/tests/auto/corelib/plugin/plugin.pro
index e6b748e4f4a..777e9209952 100644
--- a/tests/auto/corelib/plugin/plugin.pro
+++ b/tests/auto/corelib/plugin/plugin.pro
@@ -8,3 +8,9 @@ load(qfeatures)
     qpluginloader \
     qplugin \
     qlibrary
+
+contains(CONFIG, static) {
+    message(Disabling tests requiring shared build of Qt)
+    SUBDIRS -= qfactoryloader \
+               qpluginloader
+}
diff --git a/tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp b/tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp
index 3bed64a76a2..fe465df3959 100644
--- a/tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp
+++ b/tests/auto/corelib/thread/qatomicinteger/tst_qatomicinteger.cpp
@@ -357,28 +357,46 @@ void tst_QAtomicIntegerXX::loadAcquireStoreRelease()
 void tst_QAtomicIntegerXX::refDeref()
 {
     QFETCH(LargeInt, value);
-    T nextValue = T(value + 1);
-    T prevValue = T(value - 1);
+    const bool needToPreventOverflow  = TypeIsSigned && value == std::numeric_limits<T>::max();
+    const bool needToPreventUnderflow = TypeIsSigned && value == std::numeric_limits<T>::min();
+    T nextValue = T(value);
+    if (!needToPreventOverflow)
+        ++nextValue;
+    T prevValue = T(value);
+    if (!needToPreventUnderflow)
+        --prevValue;
 
     QAtomicInteger<T> atomic(value);
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.ref(), (nextValue != 0));
     QCOMPARE(atomic.load(), nextValue);
     QCOMPARE(atomic.deref(), (value != 0));
+    }
     QCOMPARE(atomic.load(), T(value));
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.deref(), (prevValue != 0));
     QCOMPARE(atomic.load(), prevValue);
     QCOMPARE(atomic.ref(), (value != 0));
+    }
     QCOMPARE(atomic.load(), T(value));
 
+    if (!needToPreventOverflow) {
     QCOMPARE(++atomic, nextValue);
     QCOMPARE(--atomic, T(value));
+    }
+    if (!needToPreventUnderflow) {
     QCOMPARE(--atomic, prevValue);
     QCOMPARE(++atomic, T(value));
+    }
 
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic++, T(value));
     QCOMPARE(atomic--, nextValue);
+    }
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic--, T(value));
     QCOMPARE(atomic++, prevValue);
+    }
     QCOMPARE(atomic.load(), T(value));
 }
 
@@ -481,53 +499,80 @@ void tst_QAtomicIntegerXX::fetchAndAdd()
     QFETCH(LargeInt, value);
     QAtomicInteger<T> atomic(value);
 
-    // note: this test has undefined behavior for signed max and min
     T parcel1 = 42;
     T parcel2 = T(0-parcel1);
-    T newValue1 = T(value) + parcel1;
-    T newValue2 = T(value) + parcel2;
 
+    const bool needToPreventOverflow  = TypeIsSigned && value > std::numeric_limits<T>::max() + parcel2;
+    const bool needToPreventUnderflow = TypeIsSigned && value < std::numeric_limits<T>::min() + parcel1;
+
+    T newValue1 = T(value);
+    if (!needToPreventOverflow)
+        newValue1 += parcel1;
+    T newValue2 = T(value);
+    if (!needToPreventUnderflow)
+        newValue2 += parcel2;
+
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndAddRelaxed(parcel1), T(value));
     QCOMPARE(atomic.load(), newValue1);
     QCOMPARE(atomic.fetchAndAddRelaxed(parcel2), newValue1);
+    }
     QCOMPARE(atomic.load(), T(value));
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndAddRelaxed(parcel2), T(value));
     QCOMPARE(atomic.load(), newValue2);
     QCOMPARE(atomic.fetchAndAddRelaxed(parcel1), newValue2);
+    }
     QCOMPARE(atomic.load(), T(value));
 
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndAddAcquire(parcel1), T(value));
     QCOMPARE(atomic.load(), newValue1);
     QCOMPARE(atomic.fetchAndAddAcquire(parcel2), newValue1);
+    }
     QCOMPARE(atomic.load(), T(value));
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndAddAcquire(parcel2), T(value));
     QCOMPARE(atomic.load(), newValue2);
     QCOMPARE(atomic.fetchAndAddAcquire(parcel1), newValue2);
+    }
     QCOMPARE(atomic.load(), T(value));
 
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndAddRelease(parcel1), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue1);
     QCOMPARE(atomic.fetchAndAddRelease(parcel2), newValue1);
+    }
     QCOMPARE(atomic.loadAcquire(), T(value));
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndAddRelease(parcel2), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue2);
     QCOMPARE(atomic.fetchAndAddRelease(parcel1), newValue2);
+    }
     QCOMPARE(atomic.loadAcquire(), T(value));
 
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndAddOrdered(parcel1), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue1);
     QCOMPARE(atomic.fetchAndAddOrdered(parcel2), newValue1);
+    }
     QCOMPARE(atomic.loadAcquire(), T(value));
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndAddOrdered(parcel2), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue2);
     QCOMPARE(atomic.fetchAndAddOrdered(parcel1), newValue2);
+    }
     QCOMPARE(atomic.loadAcquire(), T(value));
 
     // operator+=
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic += parcel1, newValue1);
     QCOMPARE(atomic += parcel2, T(value));
+    }
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic += parcel2, newValue2);
     QCOMPARE(atomic += parcel1, T(value));
+    }
 }
 
 void tst_QAtomicIntegerXX::fetchAndSub()
@@ -535,53 +580,80 @@ void tst_QAtomicIntegerXX::fetchAndSub()
     QFETCH(LargeInt, value);
     QAtomicInteger<T> atomic(value);
 
-    // note: this test has undefined behavior for signed max and min
     T parcel1 = 42;
     T parcel2 = T(0-parcel1);
-    T newValue1 = T(value) - parcel1;
-    T newValue2 = T(value) - parcel2;
 
+    const bool needToPreventOverflow  = TypeIsSigned && value > std::numeric_limits<T>::max() - parcel1;
+    const bool needToPreventUnderflow = TypeIsSigned && value < std::numeric_limits<T>::min() - parcel2;
+
+    T newValue1 = T(value);
+    if (!needToPreventUnderflow)
+        newValue1 -= parcel1;
+    T newValue2 = T(value);
+    if (!needToPreventOverflow)
+        newValue2 -= parcel2;
+
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndSubRelaxed(parcel1), T(value));
     QCOMPARE(atomic.load(), newValue1);
     QCOMPARE(atomic.fetchAndSubRelaxed(parcel2), newValue1);
+    }
     QCOMPARE(atomic.load(), T(value));
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndSubRelaxed(parcel2), T(value));
     QCOMPARE(atomic.load(), newValue2);
     QCOMPARE(atomic.fetchAndSubRelaxed(parcel1), newValue2);
+    }
     QCOMPARE(atomic.load(), T(value));
 
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndSubAcquire(parcel1), T(value));
     QCOMPARE(atomic.load(), newValue1);
     QCOMPARE(atomic.fetchAndSubAcquire(parcel2), newValue1);
+    }
     QCOMPARE(atomic.load(), T(value));
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndSubAcquire(parcel2), T(value));
     QCOMPARE(atomic.load(), newValue2);
     QCOMPARE(atomic.fetchAndSubAcquire(parcel1), newValue2);
+    }
     QCOMPARE(atomic.load(), T(value));
 
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndSubRelease(parcel1), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue1);
     QCOMPARE(atomic.fetchAndSubRelease(parcel2), newValue1);
+    }
     QCOMPARE(atomic.loadAcquire(), T(value));
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndSubRelease(parcel2), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue2);
     QCOMPARE(atomic.fetchAndSubRelease(parcel1), newValue2);
+    }
     QCOMPARE(atomic.loadAcquire(), T(value));
 
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic.fetchAndSubOrdered(parcel1), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue1);
     QCOMPARE(atomic.fetchAndSubOrdered(parcel2), newValue1);
+    }
     QCOMPARE(atomic.loadAcquire(), T(value));
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic.fetchAndSubOrdered(parcel2), T(value));
     QCOMPARE(atomic.loadAcquire(), newValue2);
     QCOMPARE(atomic.fetchAndSubOrdered(parcel1), newValue2);
+    }
     QCOMPARE(atomic.loadAcquire(), T(value));
 
     // operator-=
+    if (!needToPreventUnderflow) {
     QCOMPARE(atomic -= parcel1, newValue1);
     QCOMPARE(atomic -= parcel2, T(value));
+    }
+    if (!needToPreventOverflow) {
     QCOMPARE(atomic -= parcel2, newValue2);
     QCOMPARE(atomic -= parcel1, T(value));
+    }
 }
 
 void tst_QAtomicIntegerXX::addSub()
diff --git a/tests/auto/corelib/tools/qline/qline.pro b/tests/auto/corelib/tools/qline/qline.pro
index c66df2cd68f..81e2f17118f 100644
--- a/tests/auto/corelib/tools/qline/qline.pro
+++ b/tests/auto/corelib/tools/qline/qline.pro
@@ -2,4 +2,4 @@ CONFIG += testcase
 TARGET = tst_qline
 QT = core testlib
 SOURCES = tst_qline.cpp
-unix:!mac:!vxworks:!haiku:LIBS+=-lm
+unix:!darwin:!vxworks:!haiku:!integrity: LIBS+=-lm
diff --git a/tests/auto/corelib/tools/qrect/tst_qrect.cpp b/tests/auto/corelib/tools/qrect/tst_qrect.cpp
index 9b35cdec301..d3c6412b0df 100644
--- a/tests/auto/corelib/tools/qrect/tst_qrect.cpp
+++ b/tests/auto/corelib/tools/qrect/tst_qrect.cpp
@@ -2347,7 +2347,7 @@ void tst_QRect::center_data()
     QTest::newRow( "SmallestQRect" ) << getQRectCase( SmallestQRect ) << QPoint(1,1);
     QTest::newRow( "MiddleQRect" ) << getQRectCase( MiddleQRect ) << QPoint(0,0);
     QTest::newRow( "LargestQRect" ) << getQRectCase( LargestQRect ) << QPoint(INT_MAX/2,INT_MAX/2);
-    QTest::newRow( "SmallestCoordQRect" ) << getQRectCase( SmallestCoordQRect ) << QPoint(0,0);
+    QTest::newRow( "SmallestCoordQRect" ) << getQRectCase( SmallestCoordQRect ) << QPoint(INT_MIN, INT_MIN);
     QTest::newRow( "LargestCoordQRect" ) << getQRectCase( LargestCoordQRect ) << QPoint(0,0);
     QTest::newRow( "RandomQRect" ) << getQRectCase( RandomQRect ) << QPoint(105,207);
     QTest::newRow( "NegativeSizeQRect" ) << getQRectCase( NegativeSizeQRect ) << QPoint(-4,-4);
@@ -3169,8 +3169,7 @@ void tst_QRect::newMoveTopLeft_data()
     }
 
     {
-        QTest::newRow("LargestCoordQRect_NullQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(NullQPoint)
-            << QRect(QPoint(0,0), QPoint(INT_MAX+(0-INT_MIN),INT_MAX+(0-INT_MIN)));
+        // QTest::newRow("LargestCoordQRect_NullQPoint") -- Not tested as it would cause an overflow
         QTest::newRow("LargestCoordQRect_SmallestCoordQPoint") << getQRectCase(LargestCoordQRect) << getQPointCase(SmallestCoordQPoint)
             << QRect(QPoint(INT_MIN,INT_MIN), QPoint(INT_MAX,INT_MAX));
         // QTest::newRow("LargestCoordQRect_MiddleNegCoordQPoint") -- Not tested as it would cause an overflow
diff --git a/tests/auto/corelib/tools/qtimezone/tst_qtimezone.cpp b/tests/auto/corelib/tools/qtimezone/tst_qtimezone.cpp
index 18795435818..077a6a20f11 100644
--- a/tests/auto/corelib/tools/qtimezone/tst_qtimezone.cpp
+++ b/tests/auto/corelib/tools/qtimezone/tst_qtimezone.cpp
@@ -893,7 +893,7 @@ void tst_QTimeZone::macTest()
 
 void tst_QTimeZone::winTest()
 {
-#if defined(QT_BUILD_INTERNAL) && defined(Q_OS_WIN) && !defined(Q_OS_WINRT)
+#if defined(QT_BUILD_INTERNAL) && defined(Q_OS_WIN)
     // Known datetimes
     qint64 std = QDateTime(QDate(2012, 1, 1), QTime(0, 0, 0), Qt::UTC).toMSecsSinceEpoch();
     qint64 dst = QDateTime(QDate(2012, 6, 1), QTime(0, 0, 0), Qt::UTC).toMSecsSinceEpoch();
diff --git a/tests/auto/corelib/xml/qxmlstream/tst_qxmlstream.cpp b/tests/auto/corelib/xml/qxmlstream/tst_qxmlstream.cpp
index b889bcc6a93..8a153a45993 100644
--- a/tests/auto/corelib/xml/qxmlstream/tst_qxmlstream.cpp
+++ b/tests/auto/corelib/xml/qxmlstream/tst_qxmlstream.cpp
@@ -902,7 +902,8 @@ void tst_QXmlStream::testFalsePrematureError() const
 // Regression test for crash due to using empty QStack.
 void tst_QXmlStream::writerHangs() const
 {
-    QFile file("test.xml");
+    QTemporaryDir dir(QDir::tempPath() + QLatin1String("/tst_qxmlstream.XXXXXX"));
+    QFile file(dir.path() + "/test.xml");
 
     QVERIFY(file.open(QIODevice::WriteOnly));
 
diff --git a/tests/auto/gui/image/qicon/tst_qicon.cpp b/tests/auto/gui/image/qicon/tst_qicon.cpp
index 079b14a64ed..3c4610a892a 100644
--- a/tests/auto/gui/image/qicon/tst_qicon.cpp
+++ b/tests/auto/gui/image/qicon/tst_qicon.cpp
@@ -31,6 +31,7 @@
 #include <QImageReader>
 #include <qicon.h>
 #include <qiconengine.h>
+#include <QtCore/QStandardPaths>
 
 #include <algorithm>
 
@@ -648,9 +649,20 @@ void tst_QIcon::fromTheme()
     QVERIFY(!fullPathIcon.isNull());
 }
 
+static inline QString findGtkUpdateIconCache()
+{
+    QString binary = QLatin1String("gtk-update-icon-cache");
+#ifdef Q_OS_WIN
+    binary += QLatin1String(".exe");
+#endif
+    return QStandardPaths::findExecutable(binary);
+}
+
 void tst_QIcon::fromThemeCache()
 {
     QTemporaryDir dir;
+    QVERIFY2(dir.isValid(), qPrintable(dir.errorString()));
+
     QVERIFY(QDir().mkpath(dir.path() + QLatin1String("/testcache/16x16/actions")));
     QVERIFY(QFile(QStringLiteral(":/styles/commonstyle/images/standardbutton-open-16.png"))
         .copy( dir.path() + QLatin1String("/testcache/16x16/actions/button-open.png")));
@@ -700,11 +712,20 @@ void tst_QIcon::fromThemeCache()
     QVERIFY(!QIcon::fromTheme("button-open").isNull());
 
     // Try to run the actual gtk-update-icon-cache and make sure that icons are still found
+    const QString gtkUpdateIconCache = findGtkUpdateIconCache();
+    if (gtkUpdateIconCache.isEmpty()) {
+        QIcon::setThemeSearchPaths(QStringList());
+        QSKIP("gtk-update-icon-cache not run (binary not found)");
+    }
     QProcess process;
-    process.start(QStringLiteral("gtk-update-icon-cache"),
+    process.start(gtkUpdateIconCache,
                   QStringList() << QStringLiteral("-f") << QStringLiteral("-t") << (dir.path() + QLatin1String("/testcache")));
-    if (!process.waitForFinished())
-        QSKIP("gtk-update-icon-cache not run");
+    QVERIFY2(process.waitForStarted(), qPrintable(QLatin1String("Unable to start: ")
+                                                  + gtkUpdateIconCache + QLatin1String(": ")
+                                                  + process.errorString()));
+    QVERIFY(process.waitForFinished());
+    QCOMPARE(process.exitStatus(), QProcess::NormalExit);
+    QCOMPARE(process.exitCode(), 0);
     QVERIFY(QFileInfo(cacheName).lastModified() >= QFileInfo(dir.path() + QLatin1String("/testcache/16x16/actions")).lastModified());
     QIcon::setThemeSearchPaths(QStringList() << dir.path()); // reload themes
     QVERIFY(!QIcon::fromTheme("button-open").isNull());
diff --git a/tests/auto/gui/image/qimagewriter/tst_qimagewriter.cpp b/tests/auto/gui/image/qimagewriter/tst_qimagewriter.cpp
index ba5cfd17573..c12c8a9cf49 100644
--- a/tests/auto/gui/image/qimagewriter/tst_qimagewriter.cpp
+++ b/tests/auto/gui/image/qimagewriter/tst_qimagewriter.cpp
@@ -109,7 +109,7 @@ void tst_QImageWriter::initTestCase()
     prefix = QFINDTESTDATA("images/");
     if (prefix.isEmpty())
         QFAIL("Can't find images directory!");
-    writePrefix = m_temporaryDir.path();
+    writePrefix = m_temporaryDir.path() + QLatin1Char('/');
 }
 
 // Testing get/set functions
diff --git a/tests/auto/gui/kernel/qkeyevent/tst_qkeyevent.cpp b/tests/auto/gui/kernel/qkeyevent/tst_qkeyevent.cpp
index bd68400047e..db0bfaf6228 100644
--- a/tests/auto/gui/kernel/qkeyevent/tst_qkeyevent.cpp
+++ b/tests/auto/gui/kernel/qkeyevent/tst_qkeyevent.cpp
@@ -137,7 +137,7 @@ void tst_QKeyEvent::modifiers_data()
     for (quint64 bitmask = 1; bitmask < (1 << kNumModifiers) ; ++bitmask) {
         QVector<int> modifierCombination;
         for (quint64 modifier = 0; modifier < kNumModifiers; ++modifier) {
-            if (bitmask & (1 << modifier))
+            if (bitmask & (quint64(1) << modifier))
                 modifierCombination.append(modifier);
         }
         modifierCombinations.append(modifierCombination);
diff --git a/tests/auto/gui/painting/qpathclipper/qpathclipper.pro b/tests/auto/gui/painting/qpathclipper/qpathclipper.pro
index 2536cb24c09..e153460bf21 100644
--- a/tests/auto/gui/painting/qpathclipper/qpathclipper.pro
+++ b/tests/auto/gui/painting/qpathclipper/qpathclipper.pro
@@ -7,4 +7,4 @@ QT += gui-private testlib
 
 requires(contains(QT_CONFIG,private_tests))
 
-unix:!mac:!haiku:LIBS+=-lm
+unix:!darwin:!haiku:!integrity: LIBS += -lm
diff --git a/tests/auto/gui/painting/qpolygon/qpolygon.pro b/tests/auto/gui/painting/qpolygon/qpolygon.pro
index 9385b6458d4..6bda0f87099 100644
--- a/tests/auto/gui/painting/qpolygon/qpolygon.pro
+++ b/tests/auto/gui/painting/qpolygon/qpolygon.pro
@@ -3,6 +3,6 @@ TARGET = tst_qpolygon
 QT += testlib
 SOURCES  += tst_qpolygon.cpp
 
-unix:!mac:!haiku:LIBS+=-lm
+unix:!darwin:!haiku:!integrity: LIBS += -lm
 
 
diff --git a/tests/auto/gui/painting/qtransform/qtransform.pro b/tests/auto/gui/painting/qtransform/qtransform.pro
index 62c7518da08..6af84856280 100644
--- a/tests/auto/gui/painting/qtransform/qtransform.pro
+++ b/tests/auto/gui/painting/qtransform/qtransform.pro
@@ -3,4 +3,4 @@ TARGET = tst_qtransform
 SOURCES  += tst_qtransform.cpp
 QT += testlib
 
-unix:!mac:!haiku:LIBS+=-lm
+unix:!darwin:!haiku:!integrity: LIBS += -lm
diff --git a/tests/auto/gui/painting/qwmatrix/qwmatrix.pro b/tests/auto/gui/painting/qwmatrix/qwmatrix.pro
index efa29630913..de6454025cc 100644
--- a/tests/auto/gui/painting/qwmatrix/qwmatrix.pro
+++ b/tests/auto/gui/painting/qwmatrix/qwmatrix.pro
@@ -3,4 +3,4 @@ TARGET = tst_qwmatrix
 SOURCES  += tst_qwmatrix.cpp
 QT += testlib
 
-unix:!mac:!haiku:LIBS+=-lm
+unix:!darwin:!haiku:!integrity: LIBS += -lm
diff --git a/tests/auto/gui/text/qstatictext/qstatictext.pro b/tests/auto/gui/text/qstatictext/qstatictext.pro
index 002cead51d6..0f4906ce4d9 100644
--- a/tests/auto/gui/text/qstatictext/qstatictext.pro
+++ b/tests/auto/gui/text/qstatictext/qstatictext.pro
@@ -1,5 +1,7 @@
 CONFIG += testcase
 TARGET = tst_qstatictext
 QT += testlib
-QT += core-private gui-private
+
 SOURCES  += tst_qstatictext.cpp
+
+contains(QT_CONFIG, private_tests): QT += core-private gui-private
diff --git a/tests/auto/gui/text/qstatictext/tst_qstatictext.cpp b/tests/auto/gui/text/qstatictext/tst_qstatictext.cpp
index 7f4a11c5a56..ec30cc8b679 100644
--- a/tests/auto/gui/text/qstatictext/tst_qstatictext.cpp
+++ b/tests/auto/gui/text/qstatictext/tst_qstatictext.cpp
@@ -34,7 +34,9 @@
 #include <qstatictext.h>
 #include <qpaintengine.h>
 
+#ifdef QT_BUILD_INTERNAL
 #include <private/qstatictext_p.h>
+#endif
 
 // #define DEBUG_SAVE_IMAGE
 
@@ -89,8 +91,10 @@ private slots:
 
     void unprintableCharacter_qtbug12614();
 
+#ifdef QT_BUILD_INTERNAL
     void underlinedColor_qtbug20159();
     void textDocumentColor();
+#endif
 
 private:
     bool supportsTransformations() const;
@@ -592,6 +596,29 @@ void tst_QStaticText::plainTextVsRichText()
     QCOMPARE(imagePlainText, imageRichText);
 }
 
+static bool checkPixels(const QImage &image,
+                        Qt::GlobalColor expectedColor1, Qt::GlobalColor expectedColor2,
+                        QByteArray *errorMessage)
+{
+    const QRgb expectedRgb1 = QColor(expectedColor1).rgba();
+    const QRgb expectedRgb2 = QColor(expectedColor2).rgba();
+
+    for (int x = 0, w = image.width(); x < w; ++x) {
+        for (int y = 0, h = image.height(); y < h; ++y) {
+            const QRgb pixel = image.pixel(x, y);
+            if (pixel != expectedRgb1 && pixel != expectedRgb2) {
+                QString message;
+                QDebug(&message) << "Color mismatch in image" << image
+                    << "at" << x << ',' << y << ':' << showbase << hex << pixel
+                    << "(expected: " << expectedRgb1 << ',' << expectedRgb2 << ')';
+                *errorMessage = message.toLocal8Bit();
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
 void tst_QStaticText::setPenPlainText_data()
 {
     QTest::addColumn<QImage::Format>("format");
@@ -622,13 +649,9 @@ void tst_QStaticText::setPenPlainText()
         p.drawStaticText(0, 0, staticText);
     }
 
-    for (int x=0; x<image.width(); ++x) {
-        for (int y=0; y<image.height(); ++y) {
-            QRgb pixel = image.pixel(x, y);
-            QVERIFY(pixel == QColor(Qt::white).rgba()
-                    || pixel == QColor(Qt::yellow).rgba());
-        }
-    }
+    QByteArray errorMessage;
+    QVERIFY2(checkPixels(image, Qt::yellow, Qt::white, &errorMessage),
+             errorMessage.constData());
 }
 
 void tst_QStaticText::setPenRichText()
@@ -650,14 +673,9 @@ void tst_QStaticText::setPenRichText()
         p.drawStaticText(0, 0, staticText);
     }
 
-    QImage img = image.toImage();
-    for (int x=0; x<img.width(); ++x) {
-        for (int y=0; y<img.height(); ++y) {
-            QRgb pixel = img.pixel(x, y);
-            QVERIFY(pixel == QColor(Qt::white).rgba()
-                    || pixel == QColor(Qt::green).rgba());
-        }
-    }
+    QByteArray errorMessage;
+    QVERIFY2(checkPixels(image.toImage(), Qt::green, Qt::white, &errorMessage),
+             errorMessage.constData());
 }
 
 void tst_QStaticText::richTextOverridesPen()
@@ -679,14 +697,9 @@ void tst_QStaticText::richTextOverridesPen()
         p.drawStaticText(0, 0, staticText);
     }
 
-    QImage img = image.toImage();
-    for (int x=0; x<img.width(); ++x) {
-        for (int y=0; y<img.height(); ++y) {
-            QRgb pixel = img.pixel(x, y);
-            QVERIFY(pixel == QColor(Qt::white).rgba()
-                    || pixel == QColor(Qt::red).rgba());
-        }
-    }
+    QByteArray errorMessage;
+    QVERIFY2(checkPixels(image.toImage(), Qt::red, Qt::white, &errorMessage),
+             errorMessage.constData());
 }
 
 void tst_QStaticText::drawStruckOutText()
@@ -802,6 +815,7 @@ void tst_QStaticText::unprintableCharacter_qtbug12614()
     QVERIFY(staticText.size().isValid()); // Force layout. Should not crash.
 }
 
+#ifdef QT_BUILD_INTERNAL
 void tst_QStaticText::underlinedColor_qtbug20159()
 {
     QString multiScriptText;
@@ -838,6 +852,7 @@ void tst_QStaticText::textDocumentColor()
 
     QCOMPARE(d->items[1].color, QColor(Qt::red));
 }
+#endif
 
 QTEST_MAIN(tst_QStaticText)
 #include "tst_qstatictext.moc"
diff --git a/tests/auto/gui/text/text.pro b/tests/auto/gui/text/text.pro
index 6c0def4d639..dc67794a98d 100644
--- a/tests/auto/gui/text/text.pro
+++ b/tests/auto/gui/text/text.pro
@@ -30,6 +30,5 @@ win32:SUBDIRS -= qtextpiecetable
 !contains(QT_CONFIG, private_tests): SUBDIRS -= \
            qfontcache \
            qcssparser \
-           qstatictext \
            qtextlayout \
            qtextpiecetable \
diff --git a/tests/auto/network/access/qhttpnetworkreply/tst_qhttpnetworkreply.cpp b/tests/auto/network/access/qhttpnetworkreply/tst_qhttpnetworkreply.cpp
index 3373324c191..ec965a61b2f 100644
--- a/tests/auto/network/access/qhttpnetworkreply/tst_qhttpnetworkreply.cpp
+++ b/tests/auto/network/access/qhttpnetworkreply/tst_qhttpnetworkreply.cpp
@@ -28,6 +28,9 @@
 
 
 #include <QtTest/QtTest>
+#include <QtCore/QBuffer>
+#include <QtCore/QByteArray>
+
 #include "private/qhttpnetworkconnection_p.h"
 
 class tst_QHttpNetworkReply: public QObject
@@ -36,6 +39,9 @@ class tst_QHttpNetworkReply: public QObject
 private Q_SLOTS:
     void parseHeader_data();
     void parseHeader();
+
+    void parseEndOfHeader_data();
+    void parseEndOfHeader();
 };
 
 void tst_QHttpNetworkReply::parseHeader_data()
@@ -95,5 +101,66 @@ void tst_QHttpNetworkReply::parseHeader()
     }
 }
 
+class TestHeaderSocket : public QAbstractSocket
+{
+public:
+    explicit TestHeaderSocket(const QByteArray &input) : QAbstractSocket(QAbstractSocket::TcpSocket, Q_NULLPTR)
+    {
+        inputBuffer.setData(input);
+        inputBuffer.open(QIODevice::ReadOnly | QIODevice::Unbuffered);
+        open(QIODevice::ReadOnly | QIODevice::Unbuffered);
+    }
+
+    qint64 readData(char *data, qint64 maxlen) { return inputBuffer.read(data, maxlen); }
+
+    QBuffer inputBuffer;
+};
+
+class TestHeaderReply : public QHttpNetworkReply
+{
+public:
+    QHttpNetworkReplyPrivate *replyPrivate() { return static_cast<QHttpNetworkReplyPrivate *>(d_ptr.data()); }
+};
+
+void tst_QHttpNetworkReply::parseEndOfHeader_data()
+{
+    QTest::addColumn<QByteArray>("headers");
+    QTest::addColumn<qint64>("lengths");
+
+    QTest::newRow("CRLFCRLF") << QByteArray("Content-Type: text/html; charset=utf-8\r\n"
+                                            "Content-Length:\r\n 1024\r\n"
+                                            "Content-Encoding: gzip\r\n\r\nHTTPBODY")
+                               << qint64(90);
+
+    QTest::newRow("CRLFLF") << QByteArray("Content-Type: text/html; charset=utf-8\r\n"
+                                          "Content-Length:\r\n 1024\r\n"
+                                          "Content-Encoding: gzip\r\n\nHTTPBODY")
+                            << qint64(89);
+
+    QTest::newRow("LFCRLF") << QByteArray("Content-Type: text/html; charset=utf-8\r\n"
+                                          "Content-Length:\r\n 1024\r\n"
+                                          "Content-Encoding: gzip\n\r\nHTTPBODY")
+                            << qint64(89);
+
+    QTest::newRow("LFLF") << QByteArray("Content-Type: text/html; charset=utf-8\r\n"
+                                        "Content-Length:\r\n 1024\r\n"
+                                        "Content-Encoding: gzip\n\nHTTPBODY")
+                          << qint64(88);
+}
+
+void tst_QHttpNetworkReply::parseEndOfHeader()
+{
+    QFETCH(QByteArray, headers);
+    QFETCH(qint64, lengths);
+
+    TestHeaderSocket socket(headers);
+
+    TestHeaderReply reply;
+
+    QHttpNetworkReplyPrivate *replyPrivate = reply.replyPrivate();
+    qint64 headerBytes = replyPrivate->readHeader(&socket);
+    QCOMPARE(headerBytes, lengths);
+}
+
 QTEST_MAIN(tst_QHttpNetworkReply)
 #include "tst_qhttpnetworkreply.moc"
diff --git a/tests/auto/network/access/qnetworkreply/BLACKLIST b/tests/auto/network/access/qnetworkreply/BLACKLIST
index 3ec580dddee..0605677e29c 100644
--- a/tests/auto/network/access/qnetworkreply/BLACKLIST
+++ b/tests/auto/network/access/qnetworkreply/BLACKLIST
@@ -7,3 +7,7 @@ ubuntu-14.04
 *
 [backgroundRequestInterruption:ftp, bg, nobg]
 *
+[authenticationCacheAfterCancel:http+socksauth]
+rhel-7.1
+[authenticationCacheAfterCancel:https+socksauth]
+rhel-7.1
diff --git a/tests/auto/network/socket/qlocalsocket/BLACKLIST b/tests/auto/network/socket/qlocalsocket/BLACKLIST
deleted file mode 100644
index 11ddef30a58..00000000000
--- a/tests/auto/network/socket/qlocalsocket/BLACKLIST
+++ /dev/null
@@ -1,2 +0,0 @@
-[processConnection:1 client]
-windows
diff --git a/tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp b/tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp
index d037826410f..123fbfeb2ad 100644
--- a/tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp
+++ b/tests/auto/network/socket/qlocalsocket/tst_qlocalsocket.cpp
@@ -490,7 +490,11 @@ void tst_QLocalSocket::connectWithOldOpen()
 
 void tst_QLocalSocket::sendData_data()
 {
-    listenAndConnect_data();
+    QTest::addColumn<QString>("name");
+    QTest::addColumn<bool>("canListen");
+
+    QTest::newRow("null") << QString() << false;
+    QTest::newRow("tst_localsocket") << "tst_localsocket" << true;
 }
 
 void tst_QLocalSocket::sendData()
@@ -513,6 +517,7 @@ void tst_QLocalSocket::sendData()
     // test creating a connection
     socket.connectToServer(name);
     bool timedOut = true;
+    int expectedReadyReadSignals = 0;
 
     QCOMPARE(server.waitForNewConnection(3000, &timedOut), canListen);
 
@@ -536,15 +541,17 @@ void tst_QLocalSocket::sendData()
         out << testLine << endl;
         bool wrote = serverSocket->waitForBytesWritten(3000);
 
-        if (!socket.canReadLine())
+        if (!socket.canReadLine()) {
+            expectedReadyReadSignals = 1;
             QVERIFY(socket.waitForReadyRead());
+        }
 
         QVERIFY(socket.bytesAvailable() >= 0);
         QCOMPARE(socket.bytesToWrite(), (qint64)0);
         QCOMPARE(socket.flush(), false);
         QCOMPARE(socket.isValid(), canListen);
         QCOMPARE(socket.readBufferSize(), (qint64)0);
-        QCOMPARE(spyReadyRead.count(), 1);
+        QCOMPARE(spyReadyRead.count(), expectedReadyReadSignals);
 
         QVERIFY(testLine.startsWith(in.readLine()));
 
@@ -559,7 +566,7 @@ void tst_QLocalSocket::sendData()
     QCOMPARE(spyDisconnected.count(), canListen ? 1 : 0);
     QCOMPARE(spyError.count(), canListen ? 0 : 1);
     QCOMPARE(spyStateChanged.count(), canListen ? 4 : 2);
-    QCOMPARE(spyReadyRead.count(), canListen ? 1 : 0);
+    QCOMPARE(spyReadyRead.count(), canListen ? expectedReadyReadSignals : 0);
 
     server.close();
 
diff --git a/tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp b/tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp
index 904b26ac739..75650979424 100644
--- a/tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp
+++ b/tests/auto/network/socket/qtcpsocket/tst_qtcpsocket.cpp
@@ -197,6 +197,7 @@ private slots:
     void clientSendDataOnDelayedDisconnect();
     void serverDisconnectWithBuffered();
     void socketDiscardDataInWriteMode();
+    void writeOnReadBufferOverflow();
     void readNotificationsAfterBind();
 
 protected slots:
@@ -478,6 +479,8 @@ void tst_QTcpSocket::constructing()
     QCOMPARE(socket->localAddress(), QHostAddress());
     QCOMPARE((int) socket->peerPort(), 0);
     QCOMPARE(socket->peerAddress(), QHostAddress());
+    QCOMPARE(socket->readChannelCount(), 0);
+    QCOMPARE(socket->writeChannelCount(), 0);
     QCOMPARE(socket->error(), QTcpSocket::UnknownSocketError);
     QCOMPARE(socket->errorString(), QString("Unknown error"));
 
@@ -594,6 +597,8 @@ void tst_QTcpSocket::bind()
         } while (randomPort && attemptsLeft);
 
         QCOMPARE(socket->state(), QAbstractSocket::BoundState);
+        QCOMPARE(socket->readChannelCount(), 0);
+        QCOMPARE(socket->writeChannelCount(), 0);
         boundPort = socket->localPort();
         if (port)
             QCOMPARE(int(boundPort), port);
@@ -729,6 +734,8 @@ void tst_QTcpSocket::setSocketDescriptor()
     QCOMPARE(socket->socketDescriptor(), (qintptr)sock);
     QVERIFY(socket->waitForConnected(10000));
     QCOMPARE(socket->socketDescriptor(), (qintptr)sock);
+    QCOMPARE(socket->readChannelCount(), 1);
+    QCOMPARE(socket->writeChannelCount(), 1);
     delete socket;
 #ifdef Q_OS_WIN
     delete dummy;
@@ -764,6 +771,8 @@ void tst_QTcpSocket::blockingIMAP()
     QVERIFY(socket->waitForConnected(10000));
     QCOMPARE(socket->state(), QTcpSocket::ConnectedState);
     QVERIFY(socket->isValid());
+    QCOMPARE(socket->readChannelCount(), 1);
+    QCOMPARE(socket->writeChannelCount(), 1);
 
     // Read greeting
     QVERIFY(socket->waitForReadyRead(5000));
@@ -820,6 +829,8 @@ void tst_QTcpSocket::blockingIMAP()
 
     // Check that it's closed
     QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);
+    QCOMPARE(socket->readChannelCount(), 0);
+    QCOMPARE(socket->writeChannelCount(), 0);
 
     delete socket;
 }
@@ -860,6 +871,8 @@ void tst_QTcpSocket::timeoutConnect()
     QVERIFY(!socket->waitForConnected(1000)); //200ms is too short when using SOCKS proxy authentication
     QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);
     QCOMPARE(int(socket->error()), int(QTcpSocket::SocketTimeoutError));
+    QCOMPARE(socket->readChannelCount(), 0);
+    QCOMPARE(socket->writeChannelCount(), 0);
 
     timer.start();
     socket->connectToHost(address, 1357);
@@ -906,6 +919,8 @@ void tst_QTcpSocket::nonBlockingIMAP()
     }
 
     QCOMPARE(socket->state(), QTcpSocket::ConnectedState);
+    QCOMPARE(socket->readChannelCount(), 1);
+    QCOMPARE(socket->writeChannelCount(), 1);
 
     enterLoop(30);
     if (timeout()) {
@@ -971,6 +986,8 @@ void tst_QTcpSocket::nonBlockingIMAP()
 
     // Check that it's closed
     QCOMPARE(socket->state(), QTcpSocket::UnconnectedState);
+    QCOMPARE(socket->readChannelCount(), 0);
+    QCOMPARE(socket->writeChannelCount(), 0);
 
     delete socket;
 }
@@ -3051,6 +3068,40 @@ void tst_QTcpSocket::socketDiscardDataInWriteMode()
     delete socket;
 }
 
+// Test waitForBytesWritten() does not fail on read buffer overflow
+void tst_QTcpSocket::writeOnReadBufferOverflow()
+{
+    QFETCH_GLOBAL(bool, setProxy);
+    if (setProxy)
+        return;
+
+    QTcpServer tcpServer;
+    QTcpSocket *socket = newSocket();
+
+    QVERIFY(tcpServer.listen(QHostAddress::LocalHost));
+    socket->setReadBufferSize(1);
+    socket->connectToHost(tcpServer.serverAddress(), tcpServer.serverPort());
+    QVERIFY(socket->waitForConnected(5000));
+    QCOMPARE(socket->state(), QAbstractSocket::ConnectedState);
+
+    // Accept connection on server side
+    QVERIFY2(tcpServer.waitForNewConnection(5000), "Network timeout");
+    QTcpSocket *newConnection = tcpServer.nextPendingConnection();
+    QVERIFY(newConnection != nullptr);
+    QCOMPARE(newConnection->write("1", 2), Q_INT64_C(2));
+    QVERIFY(newConnection->flush());
+
+    // Wait for buffer overflow
+    QVERIFY(socket->waitForReadyRead(5000));
+    QCOMPARE(socket->bytesAvailable(), Q_INT64_C(1));
+    // Write data and wait for successful send
+    QVERIFY(socket->putChar(0));
+    QVERIFY(socket->waitForBytesWritten(5000));
+
+    delete newConnection;
+    delete socket;
+}
+
 // Test that the socket does not enable the read notifications in bind()
 void tst_QTcpSocket::readNotificationsAfterBind()
 {
diff --git a/tests/auto/other/qaccessibility/qaccessibility.pro b/tests/auto/other/qaccessibility/qaccessibility.pro
index ef3b469ba1a..7b3173798df 100644
--- a/tests/auto/other/qaccessibility/qaccessibility.pro
+++ b/tests/auto/other/qaccessibility/qaccessibility.pro
@@ -5,7 +5,7 @@ QT += testlib core-private gui-private widgets-private
 SOURCES += tst_qaccessibility.cpp
 HEADERS += accessiblewidgets.h
 
-unix:!mac:!haiku:LIBS+=-lm
+unix:!darwin:!haiku:!integity: LIBS += -lm
 
 wince {
 	accessneeded.files = $$QT_BUILD_TREE\\plugins\\accessible\\*.dll
diff --git a/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp b/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp
index 64e123309d6..be3a86f4de9 100644
--- a/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp
+++ b/tests/auto/sql/kernel/qsqlquery/tst_qsqlquery.cpp
@@ -1748,24 +1748,6 @@ void tst_QSqlQuery::synonyms()
     QCOMPARE( rec.field( 2 ).name().toLower(), QString( "t_varchar" ) );
 }
 
-// This class is used to test protected QSqlResult methods
-class ResultHelper: public QSqlResult
-{
-
-public:
-    ResultHelper(): QSqlResult( 0 ) {} // don't call, it's only for stupid compilers
-
-    bool execBatch( bool bindArray = false )
-    {
-        return QSqlResult::execBatch( bindArray );
-    }
-
-    QString boundValueName( int pos ) const
-    {
-        return QSqlResult::boundValueName( pos );
-    }
-};
-
 // It doesn't make sense to split this into several tests
 void tst_QSqlQuery::prepare_bind_exec()
 {
@@ -1890,81 +1872,81 @@ void tst_QSqlQuery::prepare_bind_exec()
         q.bindValue( 0, 0 );
         q.bindValue( 1, values[ 0 ] );
         QCOMPARE( q.boundValues().size(), 2 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(0) ].toInt(), 0 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(1) ].toString(), values[0] );
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(0)].toInt(), 0);
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(1)].toString(), values[0]);
         QVERIFY_SQL( q, exec() );
         QCOMPARE( q.boundValues().size(), 2 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(0) ].toInt(), 0 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(1) ].toString(), values[0] );
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(0)].toInt(), 0);
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(1)].toString(), values[0]);
 
         q.addBindValue( 1 );
         q.addBindValue( values[ 1 ] );
         QCOMPARE( q.boundValues().size(), 2 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(0) ].toInt(), 1 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(1) ].toString(), values[1] );
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(0)].toInt(), 1);
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(1)].toString(), values[1]);
         QVERIFY_SQL( q, exec() );
         QCOMPARE( q.boundValues().size(), 2 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(0) ].toInt(), 1 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(1) ].toString(), values[1] );
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(0)].toInt(), 1);
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(1)].toString(), values[1]);
 
         q.addBindValue( 2 );
         q.addBindValue( values[ 2 ] );
         QCOMPARE( q.boundValues().size(), 2 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(0) ].toInt(), 2 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(1) ].toString(), values[2] );
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(0)].toInt(), 2);
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(1)].toString(), values[2]);
         QVERIFY_SQL( q, exec() );
         QCOMPARE( q.boundValues().size(), 2 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(0) ].toInt(), 2 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(1) ].toString(), values[2] );
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(0)].toInt(), 2);
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(1)].toString(), values[2]);
 
         q.addBindValue( 3 );
         q.addBindValue( values[ 3 ] );
         QCOMPARE( q.boundValues().size(), 2 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(0) ].toInt(), 3 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(1) ].toString(), values[3] );
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(0)].toInt(), 3);
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(1)].toString(), values[3]);
         QVERIFY_SQL( q, exec() );
         QCOMPARE( q.boundValues().size(), 2 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(0) ].toInt(), 3 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(1) ].toString(), values[3] );
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(0)].toInt(), 3);
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(1)].toString(), values[3]);
 
         q.addBindValue( 4 );
         q.addBindValue( values[ 4 ] );
         QCOMPARE( q.boundValues().size(), 2 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(0) ].toInt(), 4 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(1) ].toString(), values[4] );
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(0)].toInt(), 4);
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(1)].toString(), values[4]);
         QVERIFY_SQL( q, exec() );
         QCOMPARE( q.boundValues().size(), 2 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(0) ].toInt(), 4 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(1) ].toString(), values[4] );
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(0)].toInt(), 4);
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(1)].toString(), values[4]);
 
         q.bindValue( 1, values[ 5 ] );
         q.bindValue( 0, 5 );
         QCOMPARE( q.boundValues().size(), 2 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(0) ].toInt(), 5 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(1) ].toString(), values[5] );
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(0)].toInt(), 5);
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(1)].toString(), values[5]);
         QVERIFY_SQL( q, exec() );
         QCOMPARE( q.boundValues().size(), 2 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(0) ].toInt(), 5 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(1) ].toString(), values[5] );
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(0)].toInt(), 5);
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(1)].toString(), values[5]);
 
         q.bindValue( 0, 6 );
         q.bindValue( 1, QString() );
         QCOMPARE( q.boundValues().size(), 2 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(0) ].toInt(), 6 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(1) ].toString(), QString() );
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(0)].toInt(), 6);
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(1)].toString(), QString());
         QVERIFY_SQL( q, exec() );
         QCOMPARE( q.boundValues().size(), 2 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(0) ].toInt(), 6 );
-        QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(1) ].toString(), QString() );
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(0)].toInt(), 6);
+        QCOMPARE(q.boundValues()[q.result()->boundValueName(1)].toString(), QString());
 
         if ( db.driver()->hasFeature( QSqlDriver::Unicode ) ) {
             q.bindValue( 0, 7 );
             q.bindValue( 1, utf8str );
-            QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(0) ].toInt(), 7 );
-            QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(1) ].toString(), utf8str );
+            QCOMPARE(q.boundValues()[q.result()->boundValueName(0)].toInt(), 7);
+            QCOMPARE(q.boundValues()[q.result()->boundValueName(1)].toString(), utf8str);
             QVERIFY_SQL( q, exec() );
-            QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(0) ].toInt(), 7 );
-            QCOMPARE( q.boundValues()[ ((ResultHelper*)q.result())->boundValueName(1) ].toString(), utf8str );
+            QCOMPARE(q.boundValues()[q.result()->boundValueName(0)].toInt(), 7);
+            QCOMPARE(q.boundValues()[q.result()->boundValueName(1)].toString(), utf8str);
         }
 
         QVERIFY_SQL( q, exec( "SELECT * FROM " + qtest_prepare + " order by id" ) );
diff --git a/tests/auto/testlib/selftests/cmptest/tst_cmptest.cpp b/tests/auto/testlib/selftests/cmptest/tst_cmptest.cpp
index 78bb2247cb4..204758f68ac 100644
--- a/tests/auto/testlib/selftests/cmptest/tst_cmptest.cpp
+++ b/tests/auto/testlib/selftests/cmptest/tst_cmptest.cpp
@@ -30,6 +30,7 @@
 #include <QtCore/QCoreApplication>
 #include <QtTest/QtTest>
 #ifdef QT_GUI_LIB
+#include <QtGui/QColor>
 #include <QtGui/QImage>
 #include <QtGui/QPixmap>
 #endif
@@ -135,6 +136,7 @@ private slots:
     void compareQListInt();
     void compareQListDouble();
 #ifdef QT_GUI_LIB
+    void compareQColor();
     void compareQPixmaps();
     void compareQPixmaps_data();
     void compareQImages();
@@ -346,6 +348,15 @@ void tst_Cmptest::compareQListDouble()
 }
 
 #ifdef QT_GUI_LIB
+void tst_Cmptest::compareQColor()
+{
+    const QColor yellow(Qt::yellow);
+    const QColor yellowFromName(QStringLiteral("yellow"));
+    const QColor green(Qt::green);
+    QCOMPARE(yellow, yellowFromName);
+    QCOMPARE(yellow, green);
+}
+
 void tst_Cmptest::compareQPixmaps_data()
 {
     QTest::addColumn<QPixmap>("opA");
diff --git a/tests/auto/testlib/selftests/expected_cmptest.lightxml b/tests/auto/testlib/selftests/expected_cmptest.lightxml
index 1719d2a79da..440429e430b 100644
--- a/tests/auto/testlib/selftests/expected_cmptest.lightxml
+++ b/tests/auto/testlib/selftests/expected_cmptest.lightxml
@@ -8,13 +8,13 @@
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="compare_unregistered_enums">
-<Incident type="fail" file="tst_cmptest.cpp" line="159">
+<Incident type="fail" file="tst_cmptest.cpp" line="156">
     <Description><![CDATA[Compared values are not the same]]></Description>
 </Incident>
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="compare_registered_enums">
-<Incident type="fail" file="tst_cmptest.cpp" line="165">
+<Incident type="fail" file="tst_cmptest.cpp" line="162">
     <Description><![CDATA[Compared values are not the same
    Actual   (Qt::ArrowCursor): ArrowCursor
    Expected (Qt::BusyCursor) : BusyCursor]]></Description>
@@ -22,7 +22,7 @@
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="compare_class_enums">
-<Incident type="fail" file="tst_cmptest.cpp" line="171">
+<Incident type="fail" file="tst_cmptest.cpp" line="168">
     <Description><![CDATA[Compared values are not the same
    Actual   (MyClassEnum::MyClassEnumValue1): MyClassEnumValue1
    Expected (MyClassEnum::MyClassEnumValue2): MyClassEnumValue2]]></Description>
@@ -38,7 +38,7 @@
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="compare_tostring">
-<Incident type="fail" file="tst_cmptest.cpp" line="242">
+<Incident type="fail" file="tst_cmptest.cpp" line="239">
     <DataTag><![CDATA[int, string]]></DataTag>
     <Description><![CDATA[Compared values are not the same
    Actual   (actual)  : QVariant(int,123)
@@ -47,19 +47,19 @@
 <Incident type="pass" file="" line="0">
     <DataTag><![CDATA[both invalid]]></DataTag>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="242">
+<Incident type="fail" file="tst_cmptest.cpp" line="239">
     <DataTag><![CDATA[null hash, invalid]]></DataTag>
     <Description><![CDATA[Compared values are not the same
    Actual   (actual)  : QVariant(QVariantHash)
    Expected (expected): QVariant()]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="242">
+<Incident type="fail" file="tst_cmptest.cpp" line="239">
     <DataTag><![CDATA[string, null user type]]></DataTag>
     <Description><![CDATA[Compared values are not the same
    Actual   (actual)  : QVariant(QString,A simple string)
    Expected (expected): QVariant(PhonyClass)]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="242">
+<Incident type="fail" file="tst_cmptest.cpp" line="239">
     <DataTag><![CDATA[both non-null user type]]></DataTag>
     <Description><![CDATA[Compared values are not the same
    Actual   (actual)  : QVariant(PhonyClass,<value not representable as string>)
@@ -74,31 +74,31 @@
 <Incident type="pass" file="" line="0">
     <DataTag><![CDATA[equal lists]]></DataTag>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="336">
+<Incident type="fail" file="tst_cmptest.cpp" line="333">
     <DataTag><![CDATA[last item different]]></DataTag>
     <Description><![CDATA[Compared lists differ at index 2.
    Actual   (opA): "string3"
    Expected (opB): "DIFFERS"]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="336">
+<Incident type="fail" file="tst_cmptest.cpp" line="333">
     <DataTag><![CDATA[second-last item different]]></DataTag>
     <Description><![CDATA[Compared lists differ at index 2.
    Actual   (opA): "string3"
    Expected (opB): "DIFFERS"]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="336">
+<Incident type="fail" file="tst_cmptest.cpp" line="333">
     <DataTag><![CDATA[prefix]]></DataTag>
     <Description><![CDATA[Compared lists have different sizes.
    Actual   (opA) size: 2
    Expected (opB) size: 1]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="336">
+<Incident type="fail" file="tst_cmptest.cpp" line="333">
     <DataTag><![CDATA[short list second]]></DataTag>
     <Description><![CDATA[Compared lists have different sizes.
    Actual   (opA) size: 12
    Expected (opB) size: 1]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="336">
+<Incident type="fail" file="tst_cmptest.cpp" line="333">
     <DataTag><![CDATA[short list first]]></DataTag>
     <Description><![CDATA[Compared lists have different sizes.
    Actual   (opA) size: 1
@@ -107,7 +107,7 @@
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="compareQListInt">
-<Incident type="fail" file="tst_cmptest.cpp" line="343">
+<Incident type="fail" file="tst_cmptest.cpp" line="340">
     <Description><![CDATA[Compared lists differ at index 2.
    Actual   (int1): 3
    Expected (int2): 4]]></Description>
@@ -115,24 +115,32 @@
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="compareQListDouble">
-<Incident type="fail" file="tst_cmptest.cpp" line="350">
+<Incident type="fail" file="tst_cmptest.cpp" line="347">
     <Description><![CDATA[Compared lists differ at index 0.
    Actual   (double1): 1.5
    Expected (double2): 1]]></Description>
 </Incident>
     <Duration msecs="0"/>
 </TestFunction>
+<TestFunction name="compareQColor">
+<Incident type="fail" file="tst_cmptest.cpp" line="357">
+    <Description><![CDATA[Compared values are not the same
+   Actual   (yellow): #ffff00
+   Expected (green) : #00ff00]]></Description>
+</Incident>
+    <Duration msecs="0"/>
+</TestFunction>
 <TestFunction name="compareQPixmaps">
 <Incident type="pass" file="" line="0">
     <DataTag><![CDATA[both null]]></DataTag>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="376">
+<Incident type="fail" file="tst_cmptest.cpp" line="382">
     <DataTag><![CDATA[one null]]></DataTag>
     <Description><![CDATA[Compared QPixmaps differ.
    Actual   (opA).isNull(): 1
    Expected (opB).isNull(): 0]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="376">
+<Incident type="fail" file="tst_cmptest.cpp" line="382">
     <DataTag><![CDATA[other null]]></DataTag>
     <Description><![CDATA[Compared QPixmaps differ.
    Actual   (opA).isNull(): 0
@@ -141,13 +149,13 @@
 <Incident type="pass" file="" line="0">
     <DataTag><![CDATA[equal]]></DataTag>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="376">
+<Incident type="fail" file="tst_cmptest.cpp" line="382">
     <DataTag><![CDATA[different size]]></DataTag>
     <Description><![CDATA[Compared QPixmaps differ in size.
    Actual   (opA): 11x20
    Expected (opB): 20x20]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="376">
+<Incident type="fail" file="tst_cmptest.cpp" line="382">
     <DataTag><![CDATA[different pixels]]></DataTag>
     <Description><![CDATA[Compared values are not the same]]></Description>
 </Incident>
@@ -157,13 +165,13 @@
 <Incident type="pass" file="" line="0">
     <DataTag><![CDATA[both null]]></DataTag>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="403">
+<Incident type="fail" file="tst_cmptest.cpp" line="409">
     <DataTag><![CDATA[one null]]></DataTag>
     <Description><![CDATA[Compared QImages differ.
    Actual   (opA).isNull(): 1
    Expected (opB).isNull(): 0]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="403">
+<Incident type="fail" file="tst_cmptest.cpp" line="409">
     <DataTag><![CDATA[other null]]></DataTag>
     <Description><![CDATA[Compared QImages differ.
    Actual   (opA).isNull(): 0
@@ -172,44 +180,44 @@
 <Incident type="pass" file="" line="0">
     <DataTag><![CDATA[equal]]></DataTag>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="403">
+<Incident type="fail" file="tst_cmptest.cpp" line="409">
     <DataTag><![CDATA[different size]]></DataTag>
     <Description><![CDATA[Compared QImages differ in size.
    Actual   (opA): 11x20
    Expected (opB): 20x20]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="403">
+<Incident type="fail" file="tst_cmptest.cpp" line="409">
     <DataTag><![CDATA[different format]]></DataTag>
     <Description><![CDATA[Compared QImages differ in format.
    Actual   (opA): 6
    Expected (opB): 3]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="403">
+<Incident type="fail" file="tst_cmptest.cpp" line="409">
     <DataTag><![CDATA[different pixels]]></DataTag>
     <Description><![CDATA[Compared values are not the same]]></Description>
 </Incident>
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="verify">
-<Incident type="fail" file="tst_cmptest.cpp" line="415">
+<Incident type="fail" file="tst_cmptest.cpp" line="421">
     <Description><![CDATA['opaqueFunc() < 2' returned FALSE. ()]]></Description>
 </Incident>
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="verify2">
-<Incident type="fail" file="tst_cmptest.cpp" line="421">
+<Incident type="fail" file="tst_cmptest.cpp" line="427">
     <Description><![CDATA['opaqueFunc() < 2' returned FALSE. (42)]]></Description>
 </Incident>
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="tryVerify">
-<Incident type="fail" file="tst_cmptest.cpp" line="427">
+<Incident type="fail" file="tst_cmptest.cpp" line="433">
     <Description><![CDATA['opaqueFunc() < 2' returned FALSE. ()]]></Description>
 </Incident>
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="tryVerify2">
-<Incident type="fail" file="tst_cmptest.cpp" line="433">
+<Incident type="fail" file="tst_cmptest.cpp" line="439">
     <Description><![CDATA['opaqueFunc() < 2' returned FALSE. (42)]]></Description>
 </Incident>
     <Duration msecs="0"/>
diff --git a/tests/auto/testlib/selftests/expected_cmptest.teamcity b/tests/auto/testlib/selftests/expected_cmptest.teamcity
index 4d3491403cd..dea19b60b4c 100644
--- a/tests/auto/testlib/selftests/expected_cmptest.teamcity
+++ b/tests/auto/testlib/selftests/expected_cmptest.teamcity
@@ -2,103 +2,106 @@
 ##teamcity[testStarted name='initTestCase()']
 ##teamcity[testFinished name='initTestCase()']
 ##teamcity[testStarted name='compare_unregistered_enums()']
-##teamcity[testFailed name='compare_unregistered_enums()' message='Failure! |[Loc: tst_cmptest.cpp(159)|]' details='Compared values are not the same']
+##teamcity[testFailed name='compare_unregistered_enums()' message='Failure! |[Loc: tst_cmptest.cpp(156)|]' details='Compared values are not the same']
 ##teamcity[testFinished name='compare_unregistered_enums()']
 ##teamcity[testStarted name='compare_registered_enums()']
-##teamcity[testFailed name='compare_registered_enums()' message='Failure! |[Loc: tst_cmptest.cpp(165)|]' details='Compared values are not the same|n Actual (Qt::ArrowCursor): ArrowCursor|n Expected (Qt::BusyCursor) : BusyCursor']
+##teamcity[testFailed name='compare_registered_enums()' message='Failure! |[Loc: tst_cmptest.cpp(162)|]' details='Compared values are not the same|n Actual (Qt::ArrowCursor): ArrowCursor|n Expected (Qt::BusyCursor) : BusyCursor']
 ##teamcity[testFinished name='compare_registered_enums()']
 ##teamcity[testStarted name='compare_class_enums()']
-##teamcity[testFailed name='compare_class_enums()' message='Failure! |[Loc: tst_cmptest.cpp(171)|]' details='Compared values are not the same|n Actual (MyClassEnum::MyClassEnumValue1): MyClassEnumValue1|n Expected (MyClassEnum::MyClassEnumValue2): MyClassEnumValue2']
+##teamcity[testFailed name='compare_class_enums()' message='Failure! |[Loc: tst_cmptest.cpp(168)|]' details='Compared values are not the same|n Actual (MyClassEnum::MyClassEnumValue1): MyClassEnumValue1|n Expected (MyClassEnum::MyClassEnumValue2): MyClassEnumValue2']
 ##teamcity[testFinished name='compare_class_enums()']
 ##teamcity[testStarted name='compare_boolfuncs()']
 ##teamcity[testFinished name='compare_boolfuncs()']
 ##teamcity[testStarted name='compare_pointerfuncs()']
 ##teamcity[testFinished name='compare_pointerfuncs()']
 ##teamcity[testStarted name='compare_tostring(int, string)']
-##teamcity[testFailed name='compare_tostring(int, string)' message='Failure! |[Loc: tst_cmptest.cpp(242)|]' details='Compared values are not the same|n Actual (actual) : QVariant(int,123)|n Expected (expected): QVariant(QString,hi)']
+##teamcity[testFailed name='compare_tostring(int, string)' message='Failure! |[Loc: tst_cmptest.cpp(239)|]' details='Compared values are not the same|n Actual (actual) : QVariant(int,123)|n Expected (expected): QVariant(QString,hi)']
 ##teamcity[testFinished name='compare_tostring(int, string)']
 ##teamcity[testStarted name='compare_tostring(both invalid)']
 ##teamcity[testFinished name='compare_tostring(both invalid)']
 ##teamcity[testStarted name='compare_tostring(null hash, invalid)']
-##teamcity[testFailed name='compare_tostring(null hash, invalid)' message='Failure! |[Loc: tst_cmptest.cpp(242)|]' details='Compared values are not the same|n Actual (actual) : QVariant(QVariantHash)|n Expected (expected): QVariant()']
+##teamcity[testFailed name='compare_tostring(null hash, invalid)' message='Failure! |[Loc: tst_cmptest.cpp(239)|]' details='Compared values are not the same|n Actual (actual) : QVariant(QVariantHash)|n Expected (expected): QVariant()']
 ##teamcity[testFinished name='compare_tostring(null hash, invalid)']
 ##teamcity[testStarted name='compare_tostring(string, null user type)']
-##teamcity[testFailed name='compare_tostring(string, null user type)' message='Failure! |[Loc: tst_cmptest.cpp(242)|]' details='Compared values are not the same|n Actual (actual) : QVariant(QString,A simple string)|n Expected (expected): QVariant(PhonyClass)']
+##teamcity[testFailed name='compare_tostring(string, null user type)' message='Failure! |[Loc: tst_cmptest.cpp(239)|]' details='Compared values are not the same|n Actual (actual) : QVariant(QString,A simple string)|n Expected (expected): QVariant(PhonyClass)']
 ##teamcity[testFinished name='compare_tostring(string, null user type)']
 ##teamcity[testStarted name='compare_tostring(both non-null user type)']
-##teamcity[testFailed name='compare_tostring(both non-null user type)' message='Failure! |[Loc: tst_cmptest.cpp(242)|]' details='Compared values are not the same|n Actual (actual) : QVariant(PhonyClass,<value not representable as string>)|n Expected (expected): QVariant(PhonyClass,<value not representable as string>)']
+##teamcity[testFailed name='compare_tostring(both non-null user type)' message='Failure! |[Loc: tst_cmptest.cpp(239)|]' details='Compared values are not the same|n Actual (actual) : QVariant(PhonyClass,<value not representable as string>)|n Expected (expected): QVariant(PhonyClass,<value not representable as string>)']
 ##teamcity[testFinished name='compare_tostring(both non-null user type)']
 ##teamcity[testStarted name='compareQStringLists(empty lists)']
 ##teamcity[testFinished name='compareQStringLists(empty lists)']
 ##teamcity[testStarted name='compareQStringLists(equal lists)']
 ##teamcity[testFinished name='compareQStringLists(equal lists)']
 ##teamcity[testStarted name='compareQStringLists(last item different)']
-##teamcity[testFailed name='compareQStringLists(last item different)' message='Failure! |[Loc: tst_cmptest.cpp(336)|]' details='Compared lists differ at index 2.|n Actual (opA): "string3"|n Expected (opB): "DIFFERS"']
+##teamcity[testFailed name='compareQStringLists(last item different)' message='Failure! |[Loc: tst_cmptest.cpp(333)|]' details='Compared lists differ at index 2.|n Actual (opA): "string3"|n Expected (opB): "DIFFERS"']
 ##teamcity[testFinished name='compareQStringLists(last item different)']
 ##teamcity[testStarted name='compareQStringLists(second-last item different)']
-##teamcity[testFailed name='compareQStringLists(second-last item different)' message='Failure! |[Loc: tst_cmptest.cpp(336)|]' details='Compared lists differ at index 2.|n Actual (opA): "string3"|n Expected (opB): "DIFFERS"']
+##teamcity[testFailed name='compareQStringLists(second-last item different)' message='Failure! |[Loc: tst_cmptest.cpp(333)|]' details='Compared lists differ at index 2.|n Actual (opA): "string3"|n Expected (opB): "DIFFERS"']
 ##teamcity[testFinished name='compareQStringLists(second-last item different)']
 ##teamcity[testStarted name='compareQStringLists(prefix)']
-##teamcity[testFailed name='compareQStringLists(prefix)' message='Failure! |[Loc: tst_cmptest.cpp(336)|]' details='Compared lists have different sizes.|n Actual (opA) size: 2|n Expected (opB) size: 1']
+##teamcity[testFailed name='compareQStringLists(prefix)' message='Failure! |[Loc: tst_cmptest.cpp(333)|]' details='Compared lists have different sizes.|n Actual (opA) size: 2|n Expected (opB) size: 1']
 ##teamcity[testFinished name='compareQStringLists(prefix)']
 ##teamcity[testStarted name='compareQStringLists(short list second)']
-##teamcity[testFailed name='compareQStringLists(short list second)' message='Failure! |[Loc: tst_cmptest.cpp(336)|]' details='Compared lists have different sizes.|n Actual (opA) size: 12|n Expected (opB) size: 1']
+##teamcity[testFailed name='compareQStringLists(short list second)' message='Failure! |[Loc: tst_cmptest.cpp(333)|]' details='Compared lists have different sizes.|n Actual (opA) size: 12|n Expected (opB) size: 1']
 ##teamcity[testFinished name='compareQStringLists(short list second)']
 ##teamcity[testStarted name='compareQStringLists(short list first)']
-##teamcity[testFailed name='compareQStringLists(short list first)' message='Failure! |[Loc: tst_cmptest.cpp(336)|]' details='Compared lists have different sizes.|n Actual (opA) size: 1|n Expected (opB) size: 12']
+##teamcity[testFailed name='compareQStringLists(short list first)' message='Failure! |[Loc: tst_cmptest.cpp(333)|]' details='Compared lists have different sizes.|n Actual (opA) size: 1|n Expected (opB) size: 12']
 ##teamcity[testFinished name='compareQStringLists(short list first)']
 ##teamcity[testStarted name='compareQListInt()']
-##teamcity[testFailed name='compareQListInt()' message='Failure! |[Loc: tst_cmptest.cpp(343)|]' details='Compared lists differ at index 2.|n Actual (int1): 3|n Expected (int2): 4']
+##teamcity[testFailed name='compareQListInt()' message='Failure! |[Loc: tst_cmptest.cpp(340)|]' details='Compared lists differ at index 2.|n Actual (int1): 3|n Expected (int2): 4']
 ##teamcity[testFinished name='compareQListInt()']
 ##teamcity[testStarted name='compareQListDouble()']
-##teamcity[testFailed name='compareQListDouble()' message='Failure! |[Loc: tst_cmptest.cpp(350)|]' details='Compared lists differ at index 0.|n Actual (double1): 1.5|n Expected (double2): 1']
+##teamcity[testFailed name='compareQListDouble()' message='Failure! |[Loc: tst_cmptest.cpp(347)|]' details='Compared lists differ at index 0.|n Actual (double1): 1.5|n Expected (double2): 1']
 ##teamcity[testFinished name='compareQListDouble()']
+##teamcity[testStarted name='compareQColor()']
+##teamcity[testFailed name='compareQColor()' message='Failure! |[Loc: tst_cmptest.cpp(357)|]' details='Compared values are not the same|n Actual (yellow): #ffff00|n Expected (green) : #00ff00']
+##teamcity[testFinished name='compareQColor()']
 ##teamcity[testStarted name='compareQPixmaps(both null)']
 ##teamcity[testFinished name='compareQPixmaps(both null)']
 ##teamcity[testStarted name='compareQPixmaps(one null)']
-##teamcity[testFailed name='compareQPixmaps(one null)' message='Failure! |[Loc: tst_cmptest.cpp(376)|]' details='Compared QPixmaps differ.|n Actual (opA).isNull(): 1|n Expected (opB).isNull(): 0']
+##teamcity[testFailed name='compareQPixmaps(one null)' message='Failure! |[Loc: tst_cmptest.cpp(382)|]' details='Compared QPixmaps differ.|n Actual (opA).isNull(): 1|n Expected (opB).isNull(): 0']
 ##teamcity[testFinished name='compareQPixmaps(one null)']
 ##teamcity[testStarted name='compareQPixmaps(other null)']
-##teamcity[testFailed name='compareQPixmaps(other null)' message='Failure! |[Loc: tst_cmptest.cpp(376)|]' details='Compared QPixmaps differ.|n Actual (opA).isNull(): 0|n Expected (opB).isNull(): 1']
+##teamcity[testFailed name='compareQPixmaps(other null)' message='Failure! |[Loc: tst_cmptest.cpp(382)|]' details='Compared QPixmaps differ.|n Actual (opA).isNull(): 0|n Expected (opB).isNull(): 1']
 ##teamcity[testFinished name='compareQPixmaps(other null)']
 ##teamcity[testStarted name='compareQPixmaps(equal)']
 ##teamcity[testFinished name='compareQPixmaps(equal)']
 ##teamcity[testStarted name='compareQPixmaps(different size)']
-##teamcity[testFailed name='compareQPixmaps(different size)' message='Failure! |[Loc: tst_cmptest.cpp(376)|]' details='Compared QPixmaps differ in size.|n Actual (opA): 11x20|n Expected (opB): 20x20']
+##teamcity[testFailed name='compareQPixmaps(different size)' message='Failure! |[Loc: tst_cmptest.cpp(382)|]' details='Compared QPixmaps differ in size.|n Actual (opA): 11x20|n Expected (opB): 20x20']
 ##teamcity[testFinished name='compareQPixmaps(different size)']
 ##teamcity[testStarted name='compareQPixmaps(different pixels)']
-##teamcity[testFailed name='compareQPixmaps(different pixels)' message='Failure! |[Loc: tst_cmptest.cpp(376)|]' details='Compared values are not the same']
+##teamcity[testFailed name='compareQPixmaps(different pixels)' message='Failure! |[Loc: tst_cmptest.cpp(382)|]' details='Compared values are not the same']
 ##teamcity[testFinished name='compareQPixmaps(different pixels)']
 ##teamcity[testStarted name='compareQImages(both null)']
 ##teamcity[testFinished name='compareQImages(both null)']
 ##teamcity[testStarted name='compareQImages(one null)']
-##teamcity[testFailed name='compareQImages(one null)' message='Failure! |[Loc: tst_cmptest.cpp(403)|]' details='Compared QImages differ.|n Actual (opA).isNull(): 1|n Expected (opB).isNull(): 0']
+##teamcity[testFailed name='compareQImages(one null)' message='Failure! |[Loc: tst_cmptest.cpp(409)|]' details='Compared QImages differ.|n Actual (opA).isNull(): 1|n Expected (opB).isNull(): 0']
 ##teamcity[testFinished name='compareQImages(one null)']
 ##teamcity[testStarted name='compareQImages(other null)']
-##teamcity[testFailed name='compareQImages(other null)' message='Failure! |[Loc: tst_cmptest.cpp(403)|]' details='Compared QImages differ.|n Actual (opA).isNull(): 0|n Expected (opB).isNull(): 1']
+##teamcity[testFailed name='compareQImages(other null)' message='Failure! |[Loc: tst_cmptest.cpp(409)|]' details='Compared QImages differ.|n Actual (opA).isNull(): 0|n Expected (opB).isNull(): 1']
 ##teamcity[testFinished name='compareQImages(other null)']
 ##teamcity[testStarted name='compareQImages(equal)']
 ##teamcity[testFinished name='compareQImages(equal)']
 ##teamcity[testStarted name='compareQImages(different size)']
-##teamcity[testFailed name='compareQImages(different size)' message='Failure! |[Loc: tst_cmptest.cpp(403)|]' details='Compared QImages differ in size.|n Actual (opA): 11x20|n Expected (opB): 20x20']
+##teamcity[testFailed name='compareQImages(different size)' message='Failure! |[Loc: tst_cmptest.cpp(409)|]' details='Compared QImages differ in size.|n Actual (opA): 11x20|n Expected (opB): 20x20']
 ##teamcity[testFinished name='compareQImages(different size)']
 ##teamcity[testStarted name='compareQImages(different format)']
-##teamcity[testFailed name='compareQImages(different format)' message='Failure! |[Loc: tst_cmptest.cpp(403)|]' details='Compared QImages differ in format.|n Actual (opA): 6|n Expected (opB): 3']
+##teamcity[testFailed name='compareQImages(different format)' message='Failure! |[Loc: tst_cmptest.cpp(409)|]' details='Compared QImages differ in format.|n Actual (opA): 6|n Expected (opB): 3']
 ##teamcity[testFinished name='compareQImages(different format)']
 ##teamcity[testStarted name='compareQImages(different pixels)']
-##teamcity[testFailed name='compareQImages(different pixels)' message='Failure! |[Loc: tst_cmptest.cpp(403)|]' details='Compared values are not the same']
+##teamcity[testFailed name='compareQImages(different pixels)' message='Failure! |[Loc: tst_cmptest.cpp(409)|]' details='Compared values are not the same']
 ##teamcity[testFinished name='compareQImages(different pixels)']
 ##teamcity[testStarted name='verify()']
-##teamcity[testFailed name='verify()' message='Failure! |[Loc: tst_cmptest.cpp(415)|]' details='|'opaqueFunc() < 2|' returned FALSE. ()']
+##teamcity[testFailed name='verify()' message='Failure! |[Loc: tst_cmptest.cpp(421)|]' details='|'opaqueFunc() < 2|' returned FALSE. ()']
 ##teamcity[testFinished name='verify()']
 ##teamcity[testStarted name='verify2()']
-##teamcity[testFailed name='verify2()' message='Failure! |[Loc: tst_cmptest.cpp(421)|]' details='|'opaqueFunc() < 2|' returned FALSE. (42)']
+##teamcity[testFailed name='verify2()' message='Failure! |[Loc: tst_cmptest.cpp(427)|]' details='|'opaqueFunc() < 2|' returned FALSE. (42)']
 ##teamcity[testFinished name='verify2()']
 ##teamcity[testStarted name='tryVerify()']
-##teamcity[testFailed name='tryVerify()' message='Failure! |[Loc: tst_cmptest.cpp(427)|]' details='|'opaqueFunc() < 2|' returned FALSE. ()']
+##teamcity[testFailed name='tryVerify()' message='Failure! |[Loc: tst_cmptest.cpp(433)|]' details='|'opaqueFunc() < 2|' returned FALSE. ()']
 ##teamcity[testFinished name='tryVerify()']
 ##teamcity[testStarted name='tryVerify2()']
-##teamcity[testFailed name='tryVerify2()' message='Failure! |[Loc: tst_cmptest.cpp(433)|]' details='|'opaqueFunc() < 2|' returned FALSE. (42)']
+##teamcity[testFailed name='tryVerify2()' message='Failure! |[Loc: tst_cmptest.cpp(439)|]' details='|'opaqueFunc() < 2|' returned FALSE. (42)']
 ##teamcity[testFinished name='tryVerify2()']
 ##teamcity[testStarted name='cleanupTestCase()']
 ##teamcity[testFinished name='cleanupTestCase()']
diff --git a/tests/auto/testlib/selftests/expected_cmptest.txt b/tests/auto/testlib/selftests/expected_cmptest.txt
index d4e50faaf03..100fd5e8ef4 100644
--- a/tests/auto/testlib/selftests/expected_cmptest.txt
+++ b/tests/auto/testlib/selftests/expected_cmptest.txt
@@ -2,108 +2,112 @@
 Config: Using QtTest library
 PASS   : tst_Cmptest::initTestCase()
 FAIL!  : tst_Cmptest::compare_unregistered_enums() Compared values are not the same
-   Loc: [tst_cmptest.cpp(159)]
+   Loc: [tst_cmptest.cpp(156)]
 FAIL!  : tst_Cmptest::compare_registered_enums() Compared values are not the same
    Actual   (Qt::ArrowCursor): ArrowCursor
    Expected (Qt::BusyCursor) : BusyCursor
-   Loc: [tst_cmptest.cpp(165)]
+   Loc: [tst_cmptest.cpp(162)]
 FAIL!  : tst_Cmptest::compare_class_enums() Compared values are not the same
    Actual   (MyClassEnum::MyClassEnumValue1): MyClassEnumValue1
    Expected (MyClassEnum::MyClassEnumValue2): MyClassEnumValue2
-   Loc: [tst_cmptest.cpp(171)]
+   Loc: [tst_cmptest.cpp(168)]
 PASS   : tst_Cmptest::compare_boolfuncs()
 PASS   : tst_Cmptest::compare_pointerfuncs()
 FAIL!  : tst_Cmptest::compare_tostring(int, string) Compared values are not the same
    Actual   (actual)  : QVariant(int,123)
    Expected (expected): QVariant(QString,hi)
-   Loc: [tst_cmptest.cpp(242)]
+   Loc: [tst_cmptest.cpp(239)]
 PASS   : tst_Cmptest::compare_tostring(both invalid)
 FAIL!  : tst_Cmptest::compare_tostring(null hash, invalid) Compared values are not the same
    Actual   (actual)  : QVariant(QVariantHash)
    Expected (expected): QVariant()
-   Loc: [tst_cmptest.cpp(242)]
+   Loc: [tst_cmptest.cpp(239)]
 FAIL!  : tst_Cmptest::compare_tostring(string, null user type) Compared values are not the same
    Actual   (actual)  : QVariant(QString,A simple string)
    Expected (expected): QVariant(PhonyClass)
-   Loc: [tst_cmptest.cpp(242)]
+   Loc: [tst_cmptest.cpp(239)]
 FAIL!  : tst_Cmptest::compare_tostring(both non-null user type) Compared values are not the same
    Actual   (actual)  : QVariant(PhonyClass,<value not representable as string>)
    Expected (expected): QVariant(PhonyClass,<value not representable as string>)
-   Loc: [tst_cmptest.cpp(242)]
+   Loc: [tst_cmptest.cpp(239)]
 PASS   : tst_Cmptest::compareQStringLists(empty lists)
 PASS   : tst_Cmptest::compareQStringLists(equal lists)
 FAIL!  : tst_Cmptest::compareQStringLists(last item different) Compared lists differ at index 2.
    Actual   (opA): "string3"
    Expected (opB): "DIFFERS"
-   Loc: [tst_cmptest.cpp(336)]
+   Loc: [tst_cmptest.cpp(333)]
 FAIL!  : tst_Cmptest::compareQStringLists(second-last item different) Compared lists differ at index 2.
    Actual   (opA): "string3"
    Expected (opB): "DIFFERS"
-   Loc: [tst_cmptest.cpp(336)]
+   Loc: [tst_cmptest.cpp(333)]
 FAIL!  : tst_Cmptest::compareQStringLists(prefix) Compared lists have different sizes.
    Actual   (opA) size: 2
    Expected (opB) size: 1
-   Loc: [tst_cmptest.cpp(336)]
+   Loc: [tst_cmptest.cpp(333)]
 FAIL!  : tst_Cmptest::compareQStringLists(short list second) Compared lists have different sizes.
    Actual   (opA) size: 12
    Expected (opB) size: 1
-   Loc: [tst_cmptest.cpp(336)]
+   Loc: [tst_cmptest.cpp(333)]
 FAIL!  : tst_Cmptest::compareQStringLists(short list first) Compared lists have different sizes.
    Actual   (opA) size: 1
    Expected (opB) size: 12
-   Loc: [tst_cmptest.cpp(336)]
+   Loc: [tst_cmptest.cpp(333)]
 FAIL!  : tst_Cmptest::compareQListInt() Compared lists differ at index 2.
    Actual   (int1): 3
    Expected (int2): 4
-   Loc: [tst_cmptest.cpp(343)]
+   Loc: [tst_cmptest.cpp(340)]
 FAIL!  : tst_Cmptest::compareQListDouble() Compared lists differ at index 0.
    Actual   (double1): 1.5
    Expected (double2): 1
-   Loc: [tst_cmptest.cpp(350)]
+   Loc: [tst_cmptest.cpp(347)]
+FAIL!  : tst_Cmptest::compareQColor() Compared values are not the same
+   Actual   (yellow): #ffff00
+   Expected (green) : #00ff00
+   Loc: [tst_cmptest.cpp(357)]
 PASS   : tst_Cmptest::compareQPixmaps(both null)
 FAIL!  : tst_Cmptest::compareQPixmaps(one null) Compared QPixmaps differ.
    Actual   (opA).isNull(): 1
    Expected (opB).isNull(): 0
-   Loc: [tst_cmptest.cpp(376)]
+   Loc: [tst_cmptest.cpp(382)]
 FAIL!  : tst_Cmptest::compareQPixmaps(other null) Compared QPixmaps differ.
    Actual   (opA).isNull(): 0
    Expected (opB).isNull(): 1
-   Loc: [tst_cmptest.cpp(376)]
+   Loc: [tst_cmptest.cpp(382)]
 PASS   : tst_Cmptest::compareQPixmaps(equal)
 FAIL!  : tst_Cmptest::compareQPixmaps(different size) Compared QPixmaps differ in size.
    Actual   (opA): 11x20
    Expected (opB): 20x20
-   Loc: [tst_cmptest.cpp(376)]
+   Loc: [tst_cmptest.cpp(382)]
 FAIL!  : tst_Cmptest::compareQPixmaps(different pixels) Compared values are not the same
-   Loc: [tst_cmptest.cpp(376)]
+   Loc: [tst_cmptest.cpp(382)]
 PASS   : tst_Cmptest::compareQImages(both null)
 FAIL!  : tst_Cmptest::compareQImages(one null) Compared QImages differ.
    Actual   (opA).isNull(): 1
    Expected (opB).isNull(): 0
-   Loc: [tst_cmptest.cpp(403)]
+   Loc: [tst_cmptest.cpp(409)]
 FAIL!  : tst_Cmptest::compareQImages(other null) Compared QImages differ.
    Actual   (opA).isNull(): 0
    Expected (opB).isNull(): 1
-   Loc: [tst_cmptest.cpp(403)]
+   Loc: [tst_cmptest.cpp(409)]
 PASS   : tst_Cmptest::compareQImages(equal)
 FAIL!  : tst_Cmptest::compareQImages(different size) Compared QImages differ in size.
    Actual   (opA): 11x20
    Expected (opB): 20x20
-   Loc: [tst_cmptest.cpp(403)]
+   Loc: [tst_cmptest.cpp(409)]
 FAIL!  : tst_Cmptest::compareQImages(different format) Compared QImages differ in format.
    Actual   (opA): 6
    Expected (opB): 3
-   Loc: [tst_cmptest.cpp(403)]
+   Loc: [tst_cmptest.cpp(409)]
 FAIL!  : tst_Cmptest::compareQImages(different pixels) Compared values are not the same
-   Loc: [tst_cmptest.cpp(403)]
+   Loc: [tst_cmptest.cpp(409)]
 FAIL!  : tst_Cmptest::verify() 'opaqueFunc() < 2' returned FALSE. ()
-   Loc: [tst_cmptest.cpp(415)]
-FAIL!  : tst_Cmptest::verify2() 'opaqueFunc() < 2' returned FALSE. (42)
    Loc: [tst_cmptest.cpp(421)]
-FAIL!  : tst_Cmptest::tryVerify() 'opaqueFunc() < 2' returned FALSE. ()
+FAIL!  : tst_Cmptest::verify2() 'opaqueFunc() < 2' returned FALSE. (42)
    Loc: [tst_cmptest.cpp(427)]
-FAIL!  : tst_Cmptest::tryVerify2() 'opaqueFunc() < 2' returned FALSE. (42)
+FAIL!  : tst_Cmptest::tryVerify() 'opaqueFunc() < 2' returned FALSE. ()
    Loc: [tst_cmptest.cpp(433)]
+FAIL!  : tst_Cmptest::tryVerify2() 'opaqueFunc() < 2' returned FALSE. (42)
+   Loc: [tst_cmptest.cpp(439)]
 PASS   : tst_Cmptest::cleanupTestCase()
-Totals: 11 passed, 27 failed, 0 skipped, 0 blacklisted
+Totals: 11 passed, 28 failed, 0 skipped, 0 blacklisted, 247ms
 ********* Finished testing of tst_Cmptest *********
diff --git a/tests/auto/testlib/selftests/expected_cmptest.xml b/tests/auto/testlib/selftests/expected_cmptest.xml
index d9a68e0bd1e..f45d9ba1daa 100644
--- a/tests/auto/testlib/selftests/expected_cmptest.xml
+++ b/tests/auto/testlib/selftests/expected_cmptest.xml
@@ -10,13 +10,13 @@
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="compare_unregistered_enums">
-<Incident type="fail" file="tst_cmptest.cpp" line="159">
+<Incident type="fail" file="tst_cmptest.cpp" line="156">
     <Description><![CDATA[Compared values are not the same]]></Description>
 </Incident>
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="compare_registered_enums">
-<Incident type="fail" file="tst_cmptest.cpp" line="165">
+<Incident type="fail" file="tst_cmptest.cpp" line="162">
     <Description><![CDATA[Compared values are not the same
    Actual   (Qt::ArrowCursor): ArrowCursor
    Expected (Qt::BusyCursor) : BusyCursor]]></Description>
@@ -24,7 +24,7 @@
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="compare_class_enums">
-<Incident type="fail" file="tst_cmptest.cpp" line="171">
+<Incident type="fail" file="tst_cmptest.cpp" line="168">
     <Description><![CDATA[Compared values are not the same
    Actual   (MyClassEnum::MyClassEnumValue1): MyClassEnumValue1
    Expected (MyClassEnum::MyClassEnumValue2): MyClassEnumValue2]]></Description>
@@ -40,7 +40,7 @@
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="compare_tostring">
-<Incident type="fail" file="tst_cmptest.cpp" line="242">
+<Incident type="fail" file="tst_cmptest.cpp" line="239">
     <DataTag><![CDATA[int, string]]></DataTag>
     <Description><![CDATA[Compared values are not the same
    Actual   (actual)  : QVariant(int,123)
@@ -49,19 +49,19 @@
 <Incident type="pass" file="" line="0">
     <DataTag><![CDATA[both invalid]]></DataTag>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="242">
+<Incident type="fail" file="tst_cmptest.cpp" line="239">
     <DataTag><![CDATA[null hash, invalid]]></DataTag>
     <Description><![CDATA[Compared values are not the same
    Actual   (actual)  : QVariant(QVariantHash)
    Expected (expected): QVariant()]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="242">
+<Incident type="fail" file="tst_cmptest.cpp" line="239">
     <DataTag><![CDATA[string, null user type]]></DataTag>
     <Description><![CDATA[Compared values are not the same
    Actual   (actual)  : QVariant(QString,A simple string)
    Expected (expected): QVariant(PhonyClass)]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="242">
+<Incident type="fail" file="tst_cmptest.cpp" line="239">
     <DataTag><![CDATA[both non-null user type]]></DataTag>
     <Description><![CDATA[Compared values are not the same
    Actual   (actual)  : QVariant(PhonyClass,<value not representable as string>)
@@ -76,31 +76,31 @@
 <Incident type="pass" file="" line="0">
     <DataTag><![CDATA[equal lists]]></DataTag>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="336">
+<Incident type="fail" file="tst_cmptest.cpp" line="333">
     <DataTag><![CDATA[last item different]]></DataTag>
     <Description><![CDATA[Compared lists differ at index 2.
    Actual   (opA): "string3"
    Expected (opB): "DIFFERS"]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="336">
+<Incident type="fail" file="tst_cmptest.cpp" line="333">
     <DataTag><![CDATA[second-last item different]]></DataTag>
     <Description><![CDATA[Compared lists differ at index 2.
    Actual   (opA): "string3"
    Expected (opB): "DIFFERS"]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="336">
+<Incident type="fail" file="tst_cmptest.cpp" line="333">
     <DataTag><![CDATA[prefix]]></DataTag>
     <Description><![CDATA[Compared lists have different sizes.
    Actual   (opA) size: 2
    Expected (opB) size: 1]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="336">
+<Incident type="fail" file="tst_cmptest.cpp" line="333">
     <DataTag><![CDATA[short list second]]></DataTag>
     <Description><![CDATA[Compared lists have different sizes.
    Actual   (opA) size: 12
    Expected (opB) size: 1]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="336">
+<Incident type="fail" file="tst_cmptest.cpp" line="333">
     <DataTag><![CDATA[short list first]]></DataTag>
     <Description><![CDATA[Compared lists have different sizes.
    Actual   (opA) size: 1
@@ -109,7 +109,7 @@
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="compareQListInt">
-<Incident type="fail" file="tst_cmptest.cpp" line="343">
+<Incident type="fail" file="tst_cmptest.cpp" line="340">
     <Description><![CDATA[Compared lists differ at index 2.
    Actual   (int1): 3
    Expected (int2): 4]]></Description>
@@ -117,24 +117,32 @@
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="compareQListDouble">
-<Incident type="fail" file="tst_cmptest.cpp" line="350">
+<Incident type="fail" file="tst_cmptest.cpp" line="347">
     <Description><![CDATA[Compared lists differ at index 0.
    Actual   (double1): 1.5
    Expected (double2): 1]]></Description>
 </Incident>
     <Duration msecs="0"/>
 </TestFunction>
+<TestFunction name="compareQColor">
+<Incident type="fail" file="tst_cmptest.cpp" line="357">
+    <Description><![CDATA[Compared values are not the same
+   Actual   (yellow): #ffff00
+   Expected (green) : #00ff00]]></Description>
+</Incident>
+    <Duration msecs="0"/>
+</TestFunction>
 <TestFunction name="compareQPixmaps">
 <Incident type="pass" file="" line="0">
     <DataTag><![CDATA[both null]]></DataTag>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="376">
+<Incident type="fail" file="tst_cmptest.cpp" line="382">
     <DataTag><![CDATA[one null]]></DataTag>
     <Description><![CDATA[Compared QPixmaps differ.
    Actual   (opA).isNull(): 1
    Expected (opB).isNull(): 0]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="376">
+<Incident type="fail" file="tst_cmptest.cpp" line="382">
     <DataTag><![CDATA[other null]]></DataTag>
     <Description><![CDATA[Compared QPixmaps differ.
    Actual   (opA).isNull(): 0
@@ -143,13 +151,13 @@
 <Incident type="pass" file="" line="0">
     <DataTag><![CDATA[equal]]></DataTag>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="376">
+<Incident type="fail" file="tst_cmptest.cpp" line="382">
     <DataTag><![CDATA[different size]]></DataTag>
     <Description><![CDATA[Compared QPixmaps differ in size.
    Actual   (opA): 11x20
    Expected (opB): 20x20]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="376">
+<Incident type="fail" file="tst_cmptest.cpp" line="382">
     <DataTag><![CDATA[different pixels]]></DataTag>
     <Description><![CDATA[Compared values are not the same]]></Description>
 </Incident>
@@ -159,13 +167,13 @@
 <Incident type="pass" file="" line="0">
     <DataTag><![CDATA[both null]]></DataTag>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="403">
+<Incident type="fail" file="tst_cmptest.cpp" line="409">
     <DataTag><![CDATA[one null]]></DataTag>
     <Description><![CDATA[Compared QImages differ.
    Actual   (opA).isNull(): 1
    Expected (opB).isNull(): 0]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="403">
+<Incident type="fail" file="tst_cmptest.cpp" line="409">
     <DataTag><![CDATA[other null]]></DataTag>
     <Description><![CDATA[Compared QImages differ.
    Actual   (opA).isNull(): 0
@@ -174,44 +182,44 @@
 <Incident type="pass" file="" line="0">
     <DataTag><![CDATA[equal]]></DataTag>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="403">
+<Incident type="fail" file="tst_cmptest.cpp" line="409">
     <DataTag><![CDATA[different size]]></DataTag>
     <Description><![CDATA[Compared QImages differ in size.
    Actual   (opA): 11x20
    Expected (opB): 20x20]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="403">
+<Incident type="fail" file="tst_cmptest.cpp" line="409">
     <DataTag><![CDATA[different format]]></DataTag>
     <Description><![CDATA[Compared QImages differ in format.
    Actual   (opA): 6
    Expected (opB): 3]]></Description>
 </Incident>
-<Incident type="fail" file="tst_cmptest.cpp" line="403">
+<Incident type="fail" file="tst_cmptest.cpp" line="409">
     <DataTag><![CDATA[different pixels]]></DataTag>
     <Description><![CDATA[Compared values are not the same]]></Description>
 </Incident>
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="verify">
-<Incident type="fail" file="tst_cmptest.cpp" line="415">
+<Incident type="fail" file="tst_cmptest.cpp" line="421">
     <Description><![CDATA['opaqueFunc() < 2' returned FALSE. ()]]></Description>
 </Incident>
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="verify2">
-<Incident type="fail" file="tst_cmptest.cpp" line="421">
+<Incident type="fail" file="tst_cmptest.cpp" line="427">
     <Description><![CDATA['opaqueFunc() < 2' returned FALSE. (42)]]></Description>
 </Incident>
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="tryVerify">
-<Incident type="fail" file="tst_cmptest.cpp" line="427">
+<Incident type="fail" file="tst_cmptest.cpp" line="433">
     <Description><![CDATA['opaqueFunc() < 2' returned FALSE. ()]]></Description>
 </Incident>
     <Duration msecs="0"/>
 </TestFunction>
 <TestFunction name="tryVerify2">
-<Incident type="fail" file="tst_cmptest.cpp" line="433">
+<Incident type="fail" file="tst_cmptest.cpp" line="439">
     <Description><![CDATA['opaqueFunc() < 2' returned FALSE. (42)]]></Description>
 </Incident>
     <Duration msecs="0"/>
diff --git a/tests/auto/testlib/selftests/expected_cmptest.xunitxml b/tests/auto/testlib/selftests/expected_cmptest.xunitxml
index 10918ce921e..ec2c3f023c3 100644
--- a/tests/auto/testlib/selftests/expected_cmptest.xunitxml
+++ b/tests/auto/testlib/selftests/expected_cmptest.xunitxml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" ?>
-<testsuite errors="0" failures="27" tests="17" name="tst_Cmptest">
+<testsuite errors="0" failures="28" tests="18" name="tst_Cmptest">
   <properties>
     <property value="@INSERT_QT_VERSION_HERE@" name="QTestVersion"/>
     <property value="@INSERT_QT_VERSION_HERE@" name="QtVersion"/>
@@ -62,6 +62,11 @@
    Actual   (double1): 1.5
    Expected (double2): 1" result="fail"/>
   </testcase>
+  <testcase result="fail" name="compareQColor">
+    <failure message="Compared values are not the same
+   Actual   (yellow): #ffff00
+   Expected (green) : #00ff00" result="fail"/>
+  </testcase>
   <testcase result="fail" name="compareQPixmaps">
     <failure tag="one null" message="Compared QPixmaps differ.
    Actual   (opA).isNull(): 1
diff --git a/tests/auto/testlib/selftests/generate_expected_output.py b/tests/auto/testlib/selftests/generate_expected_output.py
index 3aa8cdc9847..aed8829ed6a 100755
--- a/tests/auto/testlib/selftests/generate_expected_output.py
+++ b/tests/auto/testlib/selftests/generate_expected_output.py
@@ -34,7 +34,7 @@ import sys
 import subprocess
 import re
 
-formats = ['xml', 'txt', 'xunitxml', 'lightxml']
+formats = ['xml', 'txt', 'xunitxml', 'lightxml', 'teamcity']
 
 qtver = subprocess.check_output(['qmake', '-query', 'QT_VERSION']).strip().decode('utf-8')
 rootPath = os.getcwd()
diff --git a/tests/auto/tools/moc/tst_moc.cpp b/tests/auto/tools/moc/tst_moc.cpp
index 8895c652a59..5154351bb1a 100644
--- a/tests/auto/tools/moc/tst_moc.cpp
+++ b/tests/auto/tools/moc/tst_moc.cpp
@@ -126,6 +126,33 @@ typedef struct {
     int doNotConfuseMoc;
 } OldStyleCStruct;
 
+namespace {
+
+    class GadgetInUnnamedNS
+    {
+        Q_GADGET
+        Q_PROPERTY(int x READ x WRITE setX)
+        Q_PROPERTY(int y READ y WRITE setY)
+    public:
+        explicit GadgetInUnnamedNS(int x, int y) : m_x(x), m_y(y) {}
+        int x() const { return m_x; }
+        int y() const { return m_y; }
+        void setX(int x) { m_x = x; }
+        void setY(int y) { m_y = y; }
+
+    private:
+        int m_x, m_y;
+    };
+
+    class ObjectInUnnamedNS : public QObject
+    {
+        Q_OBJECT
+    public:
+        explicit ObjectInUnnamedNS(QObject *parent = Q_NULLPTR) : QObject(parent) {}
+    };
+
+}
+
 class Sender : public QObject
 {
     Q_OBJECT
@@ -592,6 +619,7 @@ private slots:
     void relatedMetaObjectsNameConflict_data();
     void relatedMetaObjectsNameConflict();
     void strignLiteralsInMacroExtension();
+    void unnamedNamespaceObjectsAndGadgets();
     void veryLongStringData();
     void gadgetHierarchy();
 
@@ -3417,6 +3445,28 @@ class VeryLongStringData : public QObject
     #undef repeat65534
 };
 
+void tst_Moc::unnamedNamespaceObjectsAndGadgets()
+{
+    // these just test very basic functionality of gadgets and objects
+    // defined in unnamed namespaces.
+    {
+        GadgetInUnnamedNS gadget(21, 42);
+        QCOMPARE(gadget.x(), 21);
+        QCOMPARE(gadget.y(), 42);
+        gadget.staticMetaObject.property(0).writeOnGadget(&gadget, 12);
+        gadget.staticMetaObject.property(1).writeOnGadget(&gadget, 24);
+        QCOMPARE(gadget.x(), 12);
+        QCOMPARE(gadget.y(), 24);
+    }
+
+    {
+        ObjectInUnnamedNS object;
+        QObject *qObject = &object;
+        QCOMPARE(static_cast<ObjectInUnnamedNS *>(qObject),
+                 qobject_cast<ObjectInUnnamedNS *>(qObject));
+    }
+}
+
 void tst_Moc::veryLongStringData()
 {
     const QMetaObject *mobj = &VeryLongStringData::staticMetaObject;
diff --git a/tests/auto/tools/uic/baseline/enumnostdset.ui b/tests/auto/tools/uic/baseline/enumnostdset.ui
new file mode 100644
index 00000000000..59e27b1be3f
--- /dev/null
+++ b/tests/auto/tools/uic/baseline/enumnostdset.ui
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>Form</class>
+ <widget class="QWidget" name="Form">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <widget class="WorldTimeClock" name="worldTimeClock">
+   <property name="geometry">
+    <rect>
+     <x>100</x>
+     <y>100</y>
+     <width>100</width>
+     <height>100</height>
+    </rect>
+   </property>
+   <property name="penStyle" stdset="0">
+    <enum>Qt::DashDotLine</enum>
+   </property>
+  </widget>
+ </widget>
+ <customwidgets>
+  <customwidget>
+   <class>WorldTimeClock</class>
+   <extends>QWidget</extends>
+   <header>worldtimeclock.h</header>
+  </customwidget>
+ </customwidgets>
+ <resources/>
+ <connections/>
+</ui>
diff --git a/tests/auto/tools/uic/baseline/enumnostdset.ui.h b/tests/auto/tools/uic/baseline/enumnostdset.ui.h
new file mode 100644
index 00000000000..89a8411b4a4
--- /dev/null
+++ b/tests/auto/tools/uic/baseline/enumnostdset.ui.h
@@ -0,0 +1,55 @@
+/********************************************************************************
+** Form generated from reading UI file 'enumnostdset.ui'
+**
+** Created by: Qt User Interface Compiler version 5.6.1
+**
+** WARNING! All changes made in this file will be lost when recompiling UI file!
+********************************************************************************/
+
+#ifndef ENUMNOSTDSET_H
+#define ENUMNOSTDSET_H
+
+#include <QtCore/QVariant>
+#include <QtWidgets/QAction>
+#include <QtWidgets/QApplication>
+#include <QtWidgets/QButtonGroup>
+#include <QtWidgets/QHeaderView>
+#include <QtWidgets/QWidget>
+#include "worldtimeclock.h"
+
+QT_BEGIN_NAMESPACE
+
+class Ui_Form
+{
+public:
+    WorldTimeClock *worldTimeClock;
+
+    void setupUi(QWidget *Form)
+    {
+        if (Form->objectName().isEmpty())
+            Form->setObjectName(QStringLiteral("Form"));
+        Form->resize(400, 300);
+        worldTimeClock = new WorldTimeClock(Form);
+        worldTimeClock->setObjectName(QStringLiteral("worldTimeClock"));
+        worldTimeClock->setGeometry(QRect(100, 100, 100, 100));
+        worldTimeClock->setProperty("penStyle", QVariant::fromValue(Qt::DashDotLine));
+
+        retranslateUi(Form);
+
+        QMetaObject::connectSlotsByName(Form);
+    } // setupUi
+
+    void retranslateUi(QWidget *Form)
+    {
+        Form->setWindowTitle(QApplication::translate("Form", "Form", 0));
+    } // retranslateUi
+
+};
+
+namespace Ui {
+    class Form: public Ui_Form {};
+} // namespace Ui
+
+QT_END_NAMESPACE
+
+#endif // ENUMNOSTDSET_H
diff --git a/tests/auto/widgets/dialogs/qdialog/tst_qdialog.cpp b/tests/auto/widgets/dialogs/qdialog/tst_qdialog.cpp
index 6528c24c1a9..e6a0c5e86b8 100644
--- a/tests/auto/widgets/dialogs/qdialog/tst_qdialog.cpp
+++ b/tests/auto/widgets/dialogs/qdialog/tst_qdialog.cpp
@@ -50,7 +50,7 @@ QT_FORWARD_DECLARE_CLASS(QDialog)
 class DummyDialog : public QDialog
 {
 public:
-    DummyDialog(): QDialog(0, Qt::X11BypassWindowManagerHint) {}
+    DummyDialog(): QDialog() {}
     using QDialog::showExtension;
 };
 
@@ -60,10 +60,8 @@ class tst_QDialog : public QObject
 public:
     tst_QDialog();
 
-public slots:
-    void initTestCase();
-    void cleanupTestCase();
 private slots:
+    void cleanup();
     void getSetCheck();
     void showExtension_data();
     void showExtension();
@@ -86,9 +84,6 @@ private slots:
     void transientParent_data();
     void transientParent();
     void dialogInGraphicsView();
-
-private:
-    DummyDialog *testWidget;
 };
 
 // Testing get/set functions
@@ -144,25 +139,12 @@ private:
 };
 
 tst_QDialog::tst_QDialog()
-
 {
 }
 
-void tst_QDialog::initTestCase()
+void tst_QDialog::cleanup()
 {
-    // Create the test class
-    testWidget = new DummyDialog;
-    testWidget->resize(200,200);
-    testWidget->show();
-    qApp->setActiveWindow(testWidget);
-}
-
-void tst_QDialog::cleanupTestCase()
-{
-    if (testWidget) {
-        delete testWidget;
-        testWidget = 0;
-    }
+    QVERIFY(QApplication::topLevelWidgets().isEmpty());
 }
 
 void tst_QDialog::showExtension_data()
@@ -185,44 +167,52 @@ void tst_QDialog::showExtension()
     QFETCH( QSize, extSize );
     QFETCH( bool, horizontal );
 
-    // set geometry of main dialog and extension widget
-    testWidget->setFixedSize( dlgSize );
-    QWidget *ext = new QWidget( testWidget );
-    ext->setFixedSize( extSize );
-    testWidget->setExtension( ext );
-    testWidget->setOrientation( horizontal ? Qt::Horizontal : Qt::Vertical );
+    DummyDialog testWidget;
+    testWidget.resize(200, 200);
+    testWidget.setWindowTitle(QLatin1String(QTest::currentTestFunction()) + QLatin1Char(':')
+                              + QLatin1String(QTest::currentDataTag()));
+    testWidget.show();
+    QVERIFY(QTest::qWaitForWindowExposed(&testWidget));
 
-    QCOMPARE( testWidget->size(), dlgSize );
-    QPoint oldPosition = testWidget->pos();
+    testWidget.setFixedSize( dlgSize );
+    QWidget *ext = new QWidget( &testWidget );
+    ext->setFixedSize( extSize );
+    testWidget.setExtension( ext );
+    testWidget.setOrientation( horizontal ? Qt::Horizontal : Qt::Vertical );
+
+    QCOMPARE( testWidget.size(), dlgSize );
+    QPoint oldPosition = testWidget.pos();
 
     // show
-    testWidget->showExtension( true );
+    testWidget.showExtension( true );
 //     while ( testWidget->size() == dlgSize )
 //         qApp->processEvents();
 
-    QTEST( testWidget->size(), "result"  );
+    QTEST( testWidget.size(), "result"  );
 
-    QCOMPARE(testWidget->pos(), oldPosition);
+    QCOMPARE(testWidget.pos(), oldPosition);
 
     // hide extension. back to old size ?
-    testWidget->showExtension( false );
-    QCOMPARE( testWidget->size(), dlgSize );
+    testWidget.showExtension( false );
+    QCOMPARE( testWidget.size(), dlgSize );
 
-    testWidget->setExtension( 0 );
+    testWidget.setExtension( 0 );
 }
 
 void tst_QDialog::defaultButtons()
 {
-    QLineEdit *lineEdit = new QLineEdit(testWidget);
-    QPushButton *push = new QPushButton("Button 1", testWidget);
-    QPushButton *pushTwo = new QPushButton("Button 2", testWidget);
-    QPushButton *pushThree = new QPushButton("Button 3", testWidget);
+    DummyDialog testWidget;
+    testWidget.resize(200, 200);
+    testWidget.setWindowTitle(QTest::currentTestFunction());
+    QLineEdit *lineEdit = new QLineEdit(&testWidget);
+    QPushButton *push = new QPushButton("Button 1", &testWidget);
+    QPushButton *pushTwo = new QPushButton("Button 2", &testWidget);
+    QPushButton *pushThree = new QPushButton("Button 3", &testWidget);
     pushThree->setAutoDefault(false);
 
-    //we need to show the buttons. Otherwise they won't get the focus
-    push->show();
-    pushTwo->show();
-    pushThree->show();
+    testWidget.show();
+    QApplication::setActiveWindow(&testWidget);
+    QVERIFY(QTest::qWaitForWindowActive(&testWidget));
 
     push->setDefault(true);
     QVERIFY(push->isDefault());
@@ -375,11 +365,15 @@ void tst_QDialog::showAsTool()
 #if defined(Q_OS_UNIX)
     QSKIP("Qt/X11: Skipped since activeWindow() is not respected by all window managers");
 #endif
-    ToolDialog dialog(testWidget);
-    testWidget->activateWindow();
+    DummyDialog testWidget;
+    testWidget.resize(200, 200);
+    testWidget.setWindowTitle(QTest::currentTestFunction());
+    ToolDialog dialog(&testWidget);
+    testWidget.show();
+    testWidget.activateWindow();
+    QVERIFY(QTest::qWaitForWindowActive(&testWidget));
     dialog.exec();
-    QTest::qWait(100);
-    if (testWidget->style()->styleHint(QStyle::SH_Widget_ShareActivation, 0, testWidget)) {
+    if (testWidget.style()->styleHint(QStyle::SH_Widget_ShareActivation, 0, &testWidget)) {
         QCOMPARE(dialog.wasActive(), true);
     } else {
         QCOMPARE(dialog.wasActive(), false);
@@ -602,7 +596,6 @@ void tst_QDialog::transientParent_data()
 void tst_QDialog::transientParent()
 {
     QFETCH(bool, nativewidgets);
-    testWidget->hide();
     QWidget topLevel;
     topLevel.resize(200, 200);
     topLevel.move(QGuiApplication::primaryScreen()->availableGeometry().center() - QPoint(100, 100));
diff --git a/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp b/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp
index 515ddf480fe..ae48445363c 100644
--- a/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp
+++ b/tests/auto/widgets/kernel/qwidget/tst_qwidget.cpp
@@ -442,6 +442,7 @@ private slots:
 
     void touchEventSynthesizedMouseEvent();
     void touchUpdateOnNewTouch();
+    void touchEventsForGesturePendingWidgets();
 
     void styleSheetPropagation();
 
@@ -9783,6 +9784,7 @@ public:
           m_touchUpdateCount(0),
           m_touchEndCount(0),
           m_touchEventCount(0),
+          m_gestureEventCount(0),
           m_acceptTouch(false),
           m_mouseEventCount(0),
           m_acceptMouse(true)
@@ -9820,6 +9822,9 @@ protected:
             else
                 e->ignore();
             return true;
+        case QEvent::Gesture:
+            ++m_gestureEventCount;
+            return true;
 
         case QEvent::MouseButtonPress:
         case QEvent::MouseMove:
@@ -9842,6 +9847,7 @@ public:
     int m_touchUpdateCount;
     int m_touchEndCount;
     int m_touchEventCount;
+    int m_gestureEventCount;
     bool m_acceptTouch;
     int m_mouseEventCount;
     bool m_acceptMouse;
@@ -9997,6 +10003,48 @@ void tst_QWidget::touchUpdateOnNewTouch()
     QCOMPARE(widget.m_touchEndCount, 1);
 }
 
+void tst_QWidget::touchEventsForGesturePendingWidgets()
+{
+    QTouchDevice *device = new QTouchDevice;
+    device->setType(QTouchDevice::TouchScreen);
+    QWindowSystemInterface::registerTouchDevice(device);
+
+    TouchMouseWidget parent;
+    TouchMouseWidget child(&parent);
+    parent.grabGesture(Qt::TapAndHoldGesture);
+    parent.show();
+
+    QWindow* window = parent.windowHandle();
+    QVERIFY(QTest::qWaitForWindowExposed(window));
+    QTest::qWait(500); // needed for QApplication::topLevelAt(), which is used by QGestureManager
+    QCOMPARE(child.m_touchEventCount, 0);
+    QCOMPARE(child.m_gestureEventCount, 0);
+    QCOMPARE(parent.m_touchEventCount, 0);
+    QCOMPARE(parent.m_gestureEventCount, 0);
+    QTest::touchEvent(window, device).press(0, QPoint(20, 20), window);
+    QCOMPARE(child.m_touchEventCount, 0);
+    QCOMPARE(child.m_gestureEventCount, 0);
+    QCOMPARE(parent.m_touchBeginCount, 1); // QTapAndHoldGestureRecognizer::create() sets Qt::WA_AcceptTouchEvents
+    QCOMPARE(parent.m_touchUpdateCount, 0);
+    QCOMPARE(parent.m_touchEndCount, 0);
+    QCOMPARE(parent.m_gestureEventCount, 0);
+    QTest::touchEvent(window, device).move(0, QPoint(25, 25), window);
+    QCOMPARE(child.m_touchEventCount, 0);
+    QCOMPARE(child.m_gestureEventCount, 0);
+    QCOMPARE(parent.m_touchBeginCount, 1);
+    QCOMPARE(parent.m_touchUpdateCount, 0);
+    QCOMPARE(parent.m_touchEndCount, 0);
+    QCOMPARE(parent.m_gestureEventCount, 0);
+    QTest::qWait(1000);
+    QTest::touchEvent(window, device).release(0, QPoint(25, 25), window);
+    QCOMPARE(child.m_touchEventCount, 0);
+    QCOMPARE(child.m_gestureEventCount, 0);
+    QCOMPARE(parent.m_touchBeginCount, 1);
+    QCOMPARE(parent.m_touchUpdateCount, 0);
+    QCOMPARE(parent.m_touchEndCount, 0);
+    QVERIFY(parent.m_gestureEventCount > 0);
+}
+
 void tst_QWidget::styleSheetPropagation()
 {
     QTableView tw;
diff --git a/tests/auto/widgets/widgets/qdockwidget/BLACKLIST b/tests/auto/widgets/widgets/qdockwidget/BLACKLIST
deleted file mode 100644
index 60adfb9f4bb..00000000000
--- a/tests/auto/widgets/widgets/qdockwidget/BLACKLIST
+++ /dev/null
@@ -1,2 +0,0 @@
-[restoreDockWidget]
-ubuntu-14.04
diff --git a/tests/auto/widgets/widgets/qmenu/tst_qmenu.cpp b/tests/auto/widgets/widgets/qmenu/tst_qmenu.cpp
index 17efc05f593..c3b432788bb 100644
--- a/tests/auto/widgets/widgets/qmenu/tst_qmenu.cpp
+++ b/tests/auto/widgets/widgets/qmenu/tst_qmenu.cpp
@@ -591,10 +591,19 @@ void tst_QMenu::widgetActionFocus()
     QCOMPARE(m.activeAction(), (QAction *)wa);
 }
 
+static QMenu *getTornOffMenu()
+{
+    foreach (QWidget *w, QApplication::allWidgets()) {
+        if (w->isVisible() && w->inherits("QTornOffMenu"))
+            return static_cast<QMenu *>(w);
+    }
+    return Q_NULLPTR;
+}
+
 void tst_QMenu::tearOff()
 {
     QWidget widget;
-    QMenu *menu = new QMenu(&widget);
+    QScopedPointer<QMenu> menu(new QMenu(&widget));
     QVERIFY(!menu->isTearOffEnabled()); //default value
     menu->setTearOffEnabled(true);
     menu->addAction("aaa");
@@ -607,24 +616,43 @@ void tst_QMenu::tearOff()
     widget.activateWindow();
     QVERIFY(QTest::qWaitForWindowActive(&widget));
     menu->popup(widget.geometry().topRight() + QPoint(50, 0));
-    QVERIFY(QTest::qWaitForWindowActive(menu));
+    QVERIFY(QTest::qWaitForWindowActive(menu.data()));
     QVERIFY(!menu->isTearOffMenuVisible());
 
-    QTest::mouseClick(menu, Qt::LeftButton, 0, QPoint(3, 3), 10);
+    QTest::mouseClick(menu.data(), Qt::LeftButton, 0, QPoint(3, 3), 10);
     QTRY_VERIFY(menu->isTearOffMenuVisible());
-    QPointer<QMenu> torn = 0;
-    foreach (QWidget *w, QApplication::allWidgets()) {
-        if (w->inherits("QTornOffMenu")) {
-            torn = static_cast<QMenu *>(w);
-            break;
-        }
-    }
+    QPointer<QMenu> torn = getTornOffMenu();
     QVERIFY(torn);
     QVERIFY(torn->isVisible());
 
     menu->hideTearOffMenu();
     QVERIFY(!menu->isTearOffMenuVisible());
     QVERIFY(!torn->isVisible());
+
+#ifndef QT_NO_CURSOR
+    // Test under-mouse positioning
+    menu->showTearOffMenu();
+    torn = getTornOffMenu();
+    QVERIFY(torn);
+    QVERIFY(torn->isVisible());
+    QVERIFY(menu->isTearOffMenuVisible());
+    // Some platforms include the window title bar in its geometry.
+    QTRY_COMPARE(torn->windowHandle()->position(), QCursor::pos());
+
+    menu->hideTearOffMenu();
+    QVERIFY(!menu->isTearOffMenuVisible());
+    QVERIFY(!torn->isVisible());
+
+    // Test custom positioning
+    const QPoint &pos = QCursor::pos() / 2 + QPoint(10, 10);
+    menu->showTearOffMenu(pos);
+    torn = getTornOffMenu();
+    QVERIFY(torn);
+    QVERIFY(torn->isVisible());
+    QVERIFY(menu->isTearOffMenuVisible());
+    // Some platforms include the window title bar in its geometry.
+    QTRY_COMPARE(torn->windowHandle()->position(), pos);
+#endif // QT_NO_CURSOR
 }
 
 void tst_QMenu::layoutDirection()
diff --git a/tests/auto/widgets/widgets/qtabbar/tst_qtabbar.cpp b/tests/auto/widgets/widgets/qtabbar/tst_qtabbar.cpp
index 947c251590b..550cca81455 100644
--- a/tests/auto/widgets/widgets/qtabbar/tst_qtabbar.cpp
+++ b/tests/auto/widgets/widgets/qtabbar/tst_qtabbar.cpp
@@ -274,36 +274,30 @@ void tst_QTabBar::sizeHints()
 {
     QTabBar tabBar;
     tabBar.setFont(QFont("Arial", 10));
-    tabBar.addTab("tab 01");
-    tabBar.addTab("tab 02");
-    tabBar.addTab("tab 03");
-    tabBar.addTab("tab 04");
-    tabBar.addTab("tab 05");
-    tabBar.addTab("tab 06");
-    tabBar.addTab("This is tab7");
-    tabBar.addTab("This is tab8");
-    tabBar.addTab("This is tab9 with a very long title");
 
     // No eliding and no scrolling -> tabbar becomes very wide
     tabBar.setUsesScrollButtons(false);
     tabBar.setElideMode(Qt::ElideNone);
-//    qDebug() << tabBar.minimumSizeHint() << tabBar.sizeHint();
-#ifdef Q_OS_MAC
-    QEXPECT_FAIL("", "QTBUG-27230", Abort);
-#endif
+    tabBar.addTab("tab 01");
+
+    // Fetch the minimum size hint width and make sure that we create enough
+    // tabs.
+    int minimumSizeHintWidth = tabBar.minimumSizeHint().width();
+    for (int i = 0; i <= 700 / minimumSizeHintWidth; ++i)
+        tabBar.addTab(QString("tab 0%1").arg(i+2));
+
+    //qDebug() << tabBar.minimumSizeHint() << tabBar.sizeHint();
     QVERIFY(tabBar.minimumSizeHint().width() > 700);
     QVERIFY(tabBar.sizeHint().width() > 700);
 
     // Scrolling enabled -> no reason to become very wide
     tabBar.setUsesScrollButtons(true);
- //   qDebug() << tabBar.minimumSizeHint() << tabBar.sizeHint();
     QVERIFY(tabBar.minimumSizeHint().width() < 200);
     QVERIFY(tabBar.sizeHint().width() > 700); // unchanged
 
     // Eliding enabled -> no reason to become very wide
     tabBar.setUsesScrollButtons(false);
     tabBar.setElideMode(Qt::ElideRight);
-//    qDebug() << tabBar.minimumSizeHint() << tabBar.sizeHint();
 
     // The sizeHint is very much dependent on the screen DPI value
     // so we can not really predict it.
@@ -312,7 +306,7 @@ void tst_QTabBar::sizeHints()
     QVERIFY(tabBarMinSizeHintWidth < tabBarSizeHintWidth);
     QVERIFY(tabBarSizeHintWidth > 700); // unchanged
 
-    tabBar.addTab("This is tab10 with a very long title");
+    tabBar.addTab("This is tab with a very long title");
     QVERIFY(tabBar.minimumSizeHint().width() > tabBarMinSizeHintWidth);
     QVERIFY(tabBar.sizeHint().width() > tabBarSizeHintWidth);
 }
diff --git a/tests/benchmarks/gui/image/qimageconversion/tst_qimageconversion.cpp b/tests/benchmarks/gui/image/qimageconversion/tst_qimageconversion.cpp
index 31c5520b556..7b49b897092 100644
--- a/tests/benchmarks/gui/image/qimageconversion/tst_qimageconversion.cpp
+++ b/tests/benchmarks/gui/image/qimageconversion/tst_qimageconversion.cpp
@@ -199,6 +199,7 @@ void tst_QImageConversion::convertRgb32_data()
     QTest::newRow("argb32 -> rgb666") << argb32 << QImage::Format_RGB666;
     QTest::newRow("argb32 -> argb8565pm") << argb32 << QImage::Format_ARGB8565_Premultiplied;
     QTest::newRow("argb32 -> argb4444pm") << argb32 << QImage::Format_ARGB4444_Premultiplied;
+    QTest::newRow("argb32 -> argb6666pm") << argb32 << QImage::Format_ARGB6666_Premultiplied;
 
     QTest::newRow("argb32pm -> rgb16") << argb32pm << QImage::Format_RGB16;
     QTest::newRow("argb32pm -> rgb32") << argb32pm << QImage::Format_RGB32;
@@ -212,6 +213,7 @@ void tst_QImageConversion::convertRgb32_data()
     QTest::newRow("argb32pm -> rgb666") << argb32pm << QImage::Format_RGB666;
     QTest::newRow("argb32pm -> argb8565pm") << argb32pm << QImage::Format_ARGB8565_Premultiplied;
     QTest::newRow("argb32pm -> argb4444pm") << argb32pm << QImage::Format_ARGB4444_Premultiplied;
+    QTest::newRow("argb32pm -> argb6666pm") << argb32pm << QImage::Format_ARGB6666_Premultiplied;
 }
 
 void tst_QImageConversion::convertRgb32()
@@ -235,6 +237,7 @@ void tst_QImageConversion::convertGeneric_data()
     QImage bgr30 = rgb32.convertToFormat(QImage::Format_BGR30);
     QImage a2rgb30 = argb32.convertToFormat(QImage::Format_A2RGB30_Premultiplied);
     QImage rgb666 = rgb32.convertToFormat(QImage::Format_RGB666);
+    QImage argb4444 = argb32.convertToFormat(QImage::Format_ARGB4444_Premultiplied);
 
     QTest::newRow("rgba8888 -> rgb32") << rgba32 << QImage::Format_RGB32;
     QTest::newRow("rgba8888 -> argb32") << rgba32 << QImage::Format_ARGB32;
@@ -271,6 +274,14 @@ void tst_QImageConversion::convertGeneric_data()
     QTest::newRow("rgb666 -> rgb16") << rgb666 << QImage::Format_RGB16;
     QTest::newRow("rgb666 -> rgb555") << rgb666 << QImage::Format_RGB555;
     QTest::newRow("rgb666 -> rgb30") << rgb666 << QImage::Format_RGB30;
+
+    QTest::newRow("argb4444pm -> rgb32") << argb4444 << QImage::Format_RGB32;
+    QTest::newRow("argb4444pm -> argb32") << argb4444 << QImage::Format_ARGB32;
+    QTest::newRow("argb4444pm -> argb32pm") << argb4444 << QImage::Format_ARGB32_Premultiplied;
+    QTest::newRow("argb4444pm -> rgbx8888") << argb4444 << QImage::Format_RGBX8888;
+    QTest::newRow("argb4444pm -> rgba8888pm") << argb4444 << QImage::Format_RGBA8888_Premultiplied;
+    QTest::newRow("argb4444pm -> rgb30") << argb4444 << QImage::Format_RGB30;
+    QTest::newRow("argb4444pm -> a2bgr30") << argb4444 << QImage::Format_A2BGR30_Premultiplied;
 }
 
 void tst_QImageConversion::convertGeneric()
diff --git a/tests/manual/foreignwindows/foreignwindows.pro b/tests/manual/foreignwindows/foreignwindows.pro
new file mode 100644
index 00000000000..6a370a68131
--- /dev/null
+++ b/tests/manual/foreignwindows/foreignwindows.pro
@@ -0,0 +1,6 @@
+TEMPLATE = app
+QT += widgets
+CONFIG += console c++11
+CONFIG -= app_bundle
+SOURCES += main.cpp
+include(../diaglib/diaglib.pri)
diff --git a/tests/manual/foreignwindows/main.cpp b/tests/manual/foreignwindows/main.cpp
new file mode 100644
index 00000000000..6c722a3f6fc
--- /dev/null
+++ b/tests/manual/foreignwindows/main.cpp
@@ -0,0 +1,329 @@
+/****************************************************************************
+**
+** Copyright (C) 2015 The Qt Company Ltd.
+** Contact: http://www.qt.io/licensing/
+**
+** This file is part of the test suite of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL21$
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see http://www.qt.io/terms-conditions. For further
+** information use the contact form at http://www.qt.io/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 or version 3 as published by the Free
+** Software Foundation and appearing in the file LICENSE.LGPLv21 and
+** LICENSE.LGPLv3 included in the packaging of this file. Please review the
+** following information to ensure the GNU Lesser General Public License
+** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
+** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** As a special exception, The Qt Company gives you certain additional
+** rights. These rights are described in The Qt Company LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include <QtWidgets/QAction>
+#include <QtWidgets/QApplication>
+#include <QtWidgets/QDesktopWidget>
+#include <QtWidgets/QMainWindow>
+#include <QtWidgets/QMenu>
+#include <QtWidgets/QMenuBar>
+#include <QtWidgets/QToolBar>
+
+#include <QtGui/QScreen>
+#include <QtGui/QWindow>
+
+#include <QtCore/QCommandLineOption>
+#include <QtCore/QCommandLineParser>
+#include <QtCore/QDebug>
+#include <QtCore/QSharedPointer>
+#include <QtCore/QStringList>
+#include <QtCore/QTextStream>
+#include <QtCore/QTimer>
+
+#ifdef Q_OS_WIN
+#  include <QtCore/qt_windows.h>
+#endif
+
+#include <eventfilter.h> // diaglib
+#include <nativewindowdump.h>
+#include <qwidgetdump.h>
+#include <qwindowdump.h>
+
+#include <iostream>
+#include <algorithm>
+
+QT_USE_NAMESPACE
+
+typedef QSharedPointer<QWidget> WidgetPtr;
+typedef QList<WidgetPtr> WidgetPtrList;
+typedef QList<WId> WIdList;
+
+// Create some pre-defined Windows controls by class name
+static WId createInternalWindow(const QString &name)
+{
+    WId result = 0;
+#ifdef Q_OS_WIN
+    if (name == QLatin1String("BUTTON") || name == QLatin1String("COMBOBOX")
+        || name == QLatin1String("EDIT") || name.startsWith(QLatin1String("RICHEDIT"))) {
+        const HWND hwnd =
+            CreateWindowEx(0, reinterpret_cast<const wchar_t *>(name.utf16()),
+                          L"NativeCtrl", WS_OVERLAPPEDWINDOW,
+                          CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
+                          0, 0, GetModuleHandle(NULL), NULL);
+        if (hwnd) {
+            SetWindowText(hwnd, L"Demo");
+            result = WId(hwnd);
+        } else {
+            qErrnoWarning("Cannot create window \"%s\"", qPrintable(name));
+        }
+    }
+#else // Q_OS_WIN
+    Q_UNUSED(name)
+#endif
+    return result;
+}
+
+// Embed a foreign window using createWindowContainer() providing
+// menu actions to dump information.
+class EmbeddingWindow : public QMainWindow
+{
+    Q_OBJECT
+public:
+    explicit EmbeddingWindow(QWindow *window);
+
+public slots:
+    void releaseForeignWindow();
+
+private:
+    QWindow *m_window;
+    QAction *m_releaseAction;
+};
+
+EmbeddingWindow::EmbeddingWindow(QWindow *window) : m_window(window)
+{
+    const QString title = QLatin1String("Qt ") + QLatin1String(QT_VERSION_STR)
+        + QLatin1String(" 0x") + QString::number(window->winId(), 16);
+    setWindowTitle(title);
+    setObjectName("MainWindow");
+    QWidget *container = QWidget::createWindowContainer(window, Q_NULLPTR, Qt::Widget);
+    container->setObjectName("Container");
+    setCentralWidget(container);
+
+    QMenu *fileMenu = menuBar()->addMenu("File");
+    fileMenu->setObjectName("FileMenu");
+    QToolBar *toolbar = new QToolBar;
+    addToolBar(Qt::TopToolBarArea, toolbar);
+
+    // Manipulation
+    QAction *action = fileMenu->addAction("Visible");
+    action->setCheckable(true);
+    action->setChecked(true);
+    connect(action, &QAction::toggled, m_window, &QWindow::setVisible);
+    toolbar->addAction(action);
+
+    m_releaseAction = fileMenu->addAction("Release", this, &EmbeddingWindow::releaseForeignWindow);
+    toolbar->addAction(m_releaseAction);
+
+    fileMenu->addSeparator(); // Diaglib actions
+    action = fileMenu->addAction("Dump Widgets",
+                                 this, [] () { QtDiag::dumpAllWidgets(); });
+    toolbar->addAction(action);
+    action = fileMenu->addAction("Dump Windows",
+                                 this, [] () { QtDiag::dumpAllWindows(); });
+    toolbar->addAction(action);
+    action = fileMenu->addAction("Dump Native Windows",
+                                 this, [this] () { QtDiag::dumpNativeWindows(winId()); });
+    toolbar->addAction(action);
+
+    fileMenu->addSeparator();
+    action = fileMenu->addAction("Quit", qApp, &QCoreApplication::quit);
+    toolbar->addAction(action);
+    action->setShortcut(Qt::CTRL + Qt::Key_Q);
+}
+
+void EmbeddingWindow::releaseForeignWindow()
+{
+    if (m_window) {
+        m_window->setParent(Q_NULLPTR);
+        m_window = Q_NULLPTR;
+        m_releaseAction->setEnabled(false);
+    }
+}
+
+// Dump information about foreign windows.
+class WindowDumper : public QObject {
+    Q_OBJECT
+public:
+    explicit WindowDumper(const QWindowList &watchedWindows)
+        : m_watchedWindows(watchedWindows) {}
+
+public slots:
+    void dump() const;
+
+private:
+    const QWindowList m_watchedWindows;
+};
+
+void WindowDumper::dump() const
+{
+    static int n = 0;
+    QString s;
+    QDebug debug(&s);
+    debug.nospace();
+    debug.setVerbosity(3);
+    debug << '#' << n++;
+    if (m_watchedWindows.size() > 1)
+        debug << '\n';
+    foreach (const QWindow *w, m_watchedWindows) {
+        const QPoint globalPos = w->mapToGlobal(QPoint());
+        debug << "  " << w << " pos=" << globalPos.x() << ',' << globalPos.y() << '\n';
+    }
+
+    std::cout << qPrintable(s);
+}
+
+static QString description(const QString &appName)
+{
+    QString result;
+    QTextStream(&result)
+        << "\nDumps information about foreign windows passed on the command line or\n"
+        "tests embedding foreign windows into Qt.\n\nUse cases:\n\n"
+        << appName << " -a          Dump a list of all native window ids.\n"
+        << appName << " <winid>     Dump information on the window.\n"
+        << appName << " -c <winid>  Dump information on the window continuously.\n"
+        << appName << " -e <winid>  Embed window into a Qt widget.\n"
+        << "\nOn Windows, class names of well known controls (EDIT, BUTTON...) can be\n"
+           "passed as <winid> along with -e, which will create the control.\n";
+    return result;
+}
+
+struct EventFilterOption
+{
+    const char *name;
+    const char *description;
+    QtDiag::EventFilter::EventCategories categories;
+};
+
+EventFilterOption eventFilterOptions[] = {
+{"mouse-events", "Dump mouse events.", QtDiag::EventFilter::MouseEvents},
+{"keyboard-events", "Dump keyboard events.", QtDiag::EventFilter::KeyEvents},
+{"state-events", "Dump state/focus change events.", QtDiag::EventFilter::StateChangeEvents | QtDiag::EventFilter::FocusEvents}
+};
+
+static inline bool isOptionSet(int argc, char *argv[], const char *option)
+{
+    return (argv + argc) !=
+        std::find_if(argv + 1, argv + argc,
+                     [option] (const char *arg) { return !qstrcmp(arg, option); });
+}
+
+int main(int argc, char *argv[])
+{
+    // Check for no scaling before QApplication is instantiated.
+    if (isOptionSet(argc, argv, "-s"))
+        QCoreApplication::setAttribute(Qt::AA_DisableHighDpiScaling);
+    QCoreApplication::setApplicationVersion(QLatin1String(QT_VERSION_STR));
+    QGuiApplication::setApplicationDisplayName("Foreign window tester");
+
+    QApplication app(argc, argv);
+
+    QCommandLineParser parser;
+    parser.setSingleDashWordOptionMode(QCommandLineParser::ParseAsLongOptions);
+    parser.setApplicationDescription(description(QCoreApplication::applicationName()));
+    parser.addHelpOption();
+    parser.addVersionOption();
+    QCommandLineOption noScalingDummy(QStringLiteral("s"),
+                                      QStringLiteral("Disable High DPI scaling."));
+    parser.addOption(noScalingDummy);
+    QCommandLineOption outputAllOption(QStringList() << QStringLiteral("a") << QStringLiteral("all"),
+                                       QStringLiteral("Output all native window ids (requires diaglib)."));
+    parser.addOption(outputAllOption);
+    QCommandLineOption continuousOption(QStringList() << QStringLiteral("c") << QStringLiteral("continuous"),
+                                        QStringLiteral("Output continuously."));
+    parser.addOption(continuousOption);
+    QCommandLineOption embedOption(QStringList() << QStringLiteral("e") << QStringLiteral("embed"),
+                                   QStringLiteral("Embed a foreign window into a Qt widget."));
+    parser.addOption(embedOption);
+    const int eventFilterOptionCount = int(sizeof(eventFilterOptions) / sizeof(eventFilterOptions[0]));
+    for (int i = 0; i < eventFilterOptionCount; ++i) {
+        parser.addOption(QCommandLineOption(QLatin1String(eventFilterOptions[i].name),
+                                            QLatin1String(eventFilterOptions[i].description)));
+    }
+    parser.addPositionalArgument(QStringLiteral("[windows]"), QStringLiteral("Window IDs."));
+
+    parser.process(QCoreApplication::arguments());
+
+    if (parser.isSet(outputAllOption)) {
+        QtDiag::dumpNativeWindows();
+        return 0;
+    }
+
+    QWindowList windows;
+    foreach (const QString &argument, parser.positionalArguments()) {
+        bool ok = true;
+        WId wid = createInternalWindow(argument);
+        if (!wid)
+            wid = argument.toULongLong(&ok, 0);
+        if (!wid || !ok) {
+            std::cerr << "Invalid window id: \"" << qPrintable(argument) << "\"\n";
+            return -1;
+        }
+        QWindow *foreignWindow = QWindow::fromWinId(wid);
+        foreignWindow->setObjectName("ForeignWindow" + QString::number(wid, 16));
+        windows.append(foreignWindow);
+    }
+
+    if (windows.isEmpty())
+        parser.showHelp(0);
+
+    int exitCode = 0;
+
+    if (parser.isSet(embedOption)) {
+        QtDiag::EventFilter::EventCategories eventCategories = 0;
+        for (int i = 0; i < eventFilterOptionCount; ++i) {
+            if (parser.isSet(QLatin1String(eventFilterOptions[i].name)))
+                eventCategories |= eventFilterOptions[i].categories;
+        }
+        if (eventCategories)
+            app.installEventFilter(new QtDiag::EventFilter(eventCategories, &app));
+
+        const QRect availableGeometry = QApplication::desktop()->availableGeometry(0);
+        QPoint pos = availableGeometry.topLeft() + QPoint(availableGeometry.width(), availableGeometry.height()) / 3;
+
+        WidgetPtrList mainWindows;
+        foreach (QWindow *window, windows) {
+            WidgetPtr mainWindow(new EmbeddingWindow(window));
+            mainWindow->move(pos);
+            mainWindow->resize(availableGeometry.size() / 4);
+            mainWindow->show();
+            pos += QPoint(40, 40);
+            mainWindows.append(mainWindow);
+        }
+        exitCode = app.exec();
+
+    } else if (parser.isSet(continuousOption)) {
+        WindowDumper dumper(windows);
+        dumper.dump();
+        QTimer *timer = new QTimer(&dumper);
+        QObject::connect(timer, &QTimer::timeout, &dumper, &WindowDumper::dump);
+        timer->start(1000);
+        exitCode = app.exec();
+
+    } else {
+        WindowDumper(windows).dump();
+    }
+
+    return exitCode;
+}
+
+#include "main.moc"
diff --git a/tests/manual/highdpi/dragwidget.cpp b/tests/manual/highdpi/dragwidget.cpp
index b5ad6fa63b8..fc1ea729635 100644
--- a/tests/manual/highdpi/dragwidget.cpp
+++ b/tests/manual/highdpi/dragwidget.cpp
@@ -163,7 +163,11 @@ void DragWidget::mousePressEvent(QMouseEvent *event)
     mimeData->setData("application/x-hotspot",
                       QByteArray::number(hotSpot.x()) + ' ' + QByteArray::number(hotSpot.y()));
 
-    QPixmap pixmap(child->size());
+    const qreal dpr = devicePixelRatioF() > 1 && !(QGuiApplication::keyboardModifiers() & Qt::ShiftModifier)
+        ? devicePixelRatioF() : 1;
+
+    QPixmap pixmap(child->size() * dpr);
+    pixmap.setDevicePixelRatio(dpr);
     child->render(&pixmap);
 
     QDrag *drag = new QDrag(this);
diff --git a/tests/manual/highdpi/main.cpp b/tests/manual/highdpi/main.cpp
index dcfabb213c8..bd6af75b16f 100644
--- a/tests/manual/highdpi/main.cpp
+++ b/tests/manual/highdpi/main.cpp
@@ -375,16 +375,22 @@ Labels::Labels()
 
 class MainWindow : public QMainWindow
 {
+    Q_OBJECT
 public:
     MainWindow();
     QMenu *addNewMenu(const QString &title, int itemCount = 5);
 
+private slots:
+    void maskActionToggled(bool t);
+
+private:
     QIcon qtIcon;
     QIcon qtIcon1x;
     QIcon qtIcon2x;
 
     QToolBar *fileToolBar;
     int menuCount;
+    QAction *m_maskAction;
 };
 
 MainWindow::MainWindow()
@@ -403,7 +409,12 @@ MainWindow::MainWindow()
     addNewMenu("&Edit");
     addNewMenu("&Build");
     addNewMenu("&Debug", 4);
-    addNewMenu("&Transmogrify", 7);
+    QMenu *menu = addNewMenu("&Transmogrify", 7);
+    menu->addSeparator();
+    m_maskAction = menu->addAction("Mask");
+    m_maskAction->setCheckable(true);
+    connect(m_maskAction, &QAction::toggled, this, &MainWindow::maskActionToggled);
+    fileToolBar->addAction(m_maskAction);
     addNewMenu("T&ools");
     addNewMenu("&Help", 2);
 }
@@ -426,6 +437,16 @@ QMenu *MainWindow::addNewMenu(const QString &title, int itemCount)
     return menu;
 }
 
+void MainWindow::maskActionToggled(bool t)
+{
+    if (t) {
+        QVector<QPoint> upperLeftTriangle;
+        upperLeftTriangle << QPoint(0, 0) << QPoint(width(), 0) << QPoint(0, height());
+        setMask(QRegion(QPolygon(upperLeftTriangle)));
+    } else {
+        clearMask();
+    }
+}
 
 class StandardIcons : public QWidget
 {
diff --git a/tests/manual/manual.pro b/tests/manual/manual.pro
index cffe76b2b41..8777cc6e116 100644
--- a/tests/manual/manual.pro
+++ b/tests/manual/manual.pro
@@ -2,6 +2,7 @@ TEMPLATE=subdirs
 
 SUBDIRS = bearerex \
 filetest \
+foreignwindows \
 gestures \
 inputmethodhints \
 keypadnavigation \
@@ -62,4 +63,5 @@ win32 {
 }
 
 lessThan(QT_MAJOR_VERSION, 5): SUBDIRS -= bearerex lance qnetworkaccessmanager/qget qmimedatabase qnetworkreply \
-qpainfo qscreen  socketengine xembed-raster xembed-widgets windowtransparency
+qpainfo qscreen  socketengine xembed-raster xembed-widgets windowtransparency \
+foreignwindows
diff --git a/tests/manual/touch/main.cpp b/tests/manual/touch/main.cpp
index 588fef9fd0b..fb0c8559f95 100644
--- a/tests/manual/touch/main.cpp
+++ b/tests/manual/touch/main.cpp
@@ -86,24 +86,6 @@ static void drawArrow(const QPointF &center, qreal length, qreal angleDegrees,
     painter.restore();
 }
 
-QDebug operator<<(QDebug debug, const QTouchDevice *d)
-{
-    QDebugStateSaver saver(debug);
-    debug.nospace();
-    debug << "QTouchDevice(" << d->name() << ',';
-    switch (d->type()) {
-    case QTouchDevice::TouchScreen:
-        debug << "TouchScreen";
-        break;
-    case QTouchDevice::TouchPad:
-        debug << "TouchPad";
-        break;
-    }
-    debug << ", capabilities=" << d->capabilities()
-        << ", maximumTouchPoints=" << d->maximumTouchPoints() << ')';
-    return debug;
-}
-
 // Hierarchy of classes containing gesture parameters and drawing functionality.
 class Gesture {
     Q_DISABLE_COPY(Gesture)
diff --git a/tools/configure/configureapp.cpp b/tools/configure/configureapp.cpp
index c33c2d74168..46c553ca01a 100644
--- a/tools/configure/configureapp.cpp
+++ b/tools/configure/configureapp.cpp
@@ -52,7 +52,6 @@ QT_BEGIN_NAMESPACE
 
 enum Platforms {
     WINDOWS,
-    WINDOWS_CE,
     WINDOWS_RT,
     QNX,
     ANDROID,
@@ -156,9 +155,6 @@ Configure::Configure(int& argc, char** argv) : verbose(0)
     dictionary[ "AVX2" ]            = "auto";
     dictionary[ "AVX512" ]          = "auto";
     dictionary[ "SYNCQT" ]          = "auto";
-    dictionary[ "CE_CRT" ]          = "no";
-    dictionary[ "CETEST" ]          = "auto";
-    dictionary[ "CE_SIGNATURE" ]    = "no";
     dictionary[ "AUDIO_BACKEND" ]   = "auto";
     dictionary[ "WMF_BACKEND" ]     = "no";
     dictionary[ "WMSDK" ]           = "auto";
@@ -273,8 +269,6 @@ Configure::Configure(int& argc, char** argv) : verbose(0)
     dictionary[ "STYLE_WINDOWSXP" ] = "auto";
     dictionary[ "STYLE_WINDOWSVISTA" ] = "auto";
     dictionary[ "STYLE_FUSION" ]    = "yes";
-    dictionary[ "STYLE_WINDOWSCE" ] = "no";
-    dictionary[ "STYLE_WINDOWSMOBILE" ] = "no";
 
     dictionary[ "SQL_MYSQL" ]       = "no";
     dictionary[ "SQL_ODBC" ]        = "no";
@@ -632,58 +626,12 @@ void Configure::parseCmdLine()
         else if (configCmdLine.at(i) == "-system-harfbuzz")
             dictionary[ "HARFBUZZ" ] = "system";
 
-        // CE- C runtime --------------------------------------------
-        else if (configCmdLine.at(i) == "-crt") {
-            ++i;
-            if (i == argCount)
-                break;
-            QDir cDir(configCmdLine.at(i));
-            if (!cDir.exists())
-                cout << "WARNING: Could not find directory (" << qPrintable(configCmdLine.at(i)) << ")for C runtime deployment" << endl;
-            else
-                dictionary[ "CE_CRT" ] = QDir::toNativeSeparators(cDir.absolutePath());
-        } else if (configCmdLine.at(i) == "-qt-crt") {
-            dictionary[ "CE_CRT" ] = "yes";
-        } else if (configCmdLine.at(i) == "-no-crt") {
-            dictionary[ "CE_CRT" ] = "no";
-        }
-        // cetest ---------------------------------------------------
-        else if (configCmdLine.at(i) == "-no-cetest") {
-            dictionary[ "CETEST" ] = "no";
-            dictionary[ "CETEST_REQUESTED" ] = "no";
-        } else if (configCmdLine.at(i) == "-cetest") {
-            // although specified to use it, we stay at "auto" state
-            // this is because checkAvailability() adds variables
-            // we need for crosscompilation; but remember if we asked
-            // for it.
-            dictionary[ "CETEST_REQUESTED" ] = "yes";
-        }
-        // Qt/CE - signing tool -------------------------------------
-        else if (configCmdLine.at(i) == "-signature") {
-            ++i;
-            if (i == argCount)
-                break;
-            QFileInfo info(configCmdLine.at(i));
-            if (!info.exists())
-                cout << "WARNING: Could not find signature file (" << qPrintable(configCmdLine.at(i)) << ")" << endl;
-            else
-                dictionary[ "CE_SIGNATURE" ] = QDir::toNativeSeparators(info.absoluteFilePath());
-        }
         // Styles ---------------------------------------------------
         else if (configCmdLine.at(i) == "-qt-style-windows")
             dictionary[ "STYLE_WINDOWS" ] = "yes";
         else if (configCmdLine.at(i) == "-no-style-windows")
             dictionary[ "STYLE_WINDOWS" ] = "no";
 
-        else if (configCmdLine.at(i) == "-qt-style-windowsce")
-            dictionary[ "STYLE_WINDOWSCE" ] = "yes";
-        else if (configCmdLine.at(i) == "-no-style-windowsce")
-            dictionary[ "STYLE_WINDOWSCE" ] = "no";
-        else if (configCmdLine.at(i) == "-qt-style-windowsmobile")
-            dictionary[ "STYLE_WINDOWSMOBILE" ] = "yes";
-        else if (configCmdLine.at(i) == "-no-style-windowsmobile")
-            dictionary[ "STYLE_WINDOWSMOBILE" ] = "no";
-
         else if (configCmdLine.at(i) == "-qt-style-windowsxp")
             dictionary[ "STYLE_WINDOWSXP" ] = "yes";
         else if (configCmdLine.at(i) == "-no-style-windowsxp")
@@ -1352,6 +1300,14 @@ void Configure::parseCmdLine()
             dictionary[ "ANDROID_PLATFORM" ] = configCmdLine.at(i);
         }
 
+        else if (configCmdLine.at(i) == "-android-ndk-host") {
+            ++i;
+            if (i == argCount)
+                break;
+
+            dictionary[ "ANDROID_HOST" ] = configCmdLine.at(i);
+        }
+
         else if (configCmdLine.at(i) == "-android-arch") {
             ++i;
             if (i == argCount)
@@ -1448,28 +1404,6 @@ void Configure::parseCmdLine()
         }
     }
 
-    // Ensure that the crt to be deployed can be found
-    if (dictionary["CE_CRT"] != QLatin1String("yes") && dictionary["CE_CRT"] != QLatin1String("no")) {
-        QDir cDir(dictionary["CE_CRT"]);
-        QStringList entries = cDir.entryList();
-        bool hasDebug = entries.contains("msvcr80.dll");
-        bool hasRelease = entries.contains("msvcr80d.dll");
-        if ((dictionary["BUILDALL"] == "auto") && (!hasDebug || !hasRelease)) {
-            cout << "Could not find debug and release c-runtime." << endl;
-            cout << "You need to have msvcr80.dll and msvcr80d.dll in" << endl;
-            cout << "the path specified. Setting to -no-crt";
-            dictionary[ "CE_CRT" ] = "no";
-        } else if ((dictionary["BUILD"] == "debug") && !hasDebug) {
-            cout << "Could not find debug c-runtime (msvcr80d.dll) in the directory specified." << endl;
-            cout << "Setting c-runtime automatic deployment to -no-crt" << endl;
-            dictionary[ "CE_CRT" ] = "no";
-        } else if ((dictionary["BUILD"] == "release") && !hasRelease) {
-            cout << "Could not find release c-runtime (msvcr80.dll) in the directory specified." << endl;
-            cout << "Setting c-runtime automatic deployment to -no-crt" << endl;
-            dictionary[ "CE_CRT" ] = "no";
-        }
-    }
-
     // Allow tests for private classes to be compiled against internal builds
     if (dictionary["BUILDDEV"] == "yes") {
         qtConfig << "private_tests";
@@ -1665,33 +1599,9 @@ void Configure::applySpecSpecifics()
         dictionary[ "SYSTEM_ZLIB" ]         = "no";
         dictionary[ "PCRE" ]                = "qt";
         dictionary[ "ICU" ]                 = "qt";
-        dictionary[ "CE_CRT" ]              = "yes";
         dictionary[ "LARGE_FILE" ]          = "no";
         dictionary[ "ANGLE" ]               = "yes";
         dictionary[ "DYNAMICGL" ]           = "no";
-    } else if (dictionary.value("XQMAKESPEC").startsWith("wince")) {
-        dictionary[ "STYLE_WINDOWSXP" ]     = "no";
-        dictionary[ "STYLE_WINDOWSVISTA" ]  = "no";
-        dictionary[ "STYLE_FUSION" ]        = "no";
-        dictionary[ "STYLE_WINDOWSCE" ]     = "yes";
-        dictionary[ "STYLE_WINDOWSMOBILE" ] = "yes";
-        dictionary[ "OPENGL" ]              = "no";
-        dictionary[ "RTTI" ]                = "no";
-        dictionary[ "SSE2" ]                = "no";
-        dictionary[ "SSE3" ]                = "no";
-        dictionary[ "SSSE3" ]               = "no";
-        dictionary[ "SSE4_1" ]              = "no";
-        dictionary[ "SSE4_2" ]              = "no";
-        dictionary[ "AVX" ]                 = "no";
-        dictionary[ "AVX2" ]                = "no";
-        dictionary[ "AVX512" ]              = "no";
-        dictionary[ "CE_CRT" ]              = "yes";
-        dictionary[ "LARGE_FILE" ]          = "no";
-        dictionary[ "ANGLE" ]               = "no";
-        dictionary[ "DYNAMICGL" ]           = "no";
-        if (dictionary[ "XQMAKESPEC" ].startsWith("wincewm")) {
-            dictionary[ "MMX" ]    = "yes";
-        }
     } else if (dictionary.value("XQMAKESPEC").startsWith("linux")) { //TODO actually wrong.
       //TODO
         dictionary[ "STYLE_WINDOWSXP" ]     = "no";
@@ -2040,8 +1950,6 @@ bool Configure::displayHelp()
         desc("STYLE_WINDOWSXP", "auto", "",             "  windowsxp", ' ');
         desc("STYLE_WINDOWSVISTA", "auto", "",          "  windowsvista", ' ');
         desc("STYLE_FUSION", "yes", "",                 "  fusion", ' ');
-        desc("STYLE_WINDOWSCE", "yes", "",              "  windowsce", ' ');
-        desc("STYLE_WINDOWSMOBILE" , "yes", "",         "  windowsmobile\n", ' ');
         desc("NATIVE_GESTURES", "no", "-no-native-gestures", "Do not use native gestures on Windows 7.");
         desc("NATIVE_GESTURES", "yes", "-native-gestures", "Use native gestures on Windows 7.\n");
         desc("MSVC_MP", "no", "-no-mp",                 "Do not use multiple processors for compiling with MSVC");
@@ -2051,15 +1959,6 @@ bool Configure::displayHelp()
         desc(                   "-saveconfig <config>", "Run configure and save the parameters in file configure_<config>.cache.");
         desc(                   "-redo",                "Run configure with the same parameters as last time.\n");
         desc(                   "-v, -verbose",         "Run configure tests with verbose output.\n");
-
-        // Qt\Windows CE only options go below here -----------------------------------------------------------------------------
-        desc("Qt for Windows CE only:\n\n");
-        desc("CE_CRT", "no",       "-no-crt" ,             "Do not add the C runtime to default deployment rules.");
-        desc("CE_CRT", "yes",      "-qt-crt",              "Qt identifies C runtime during project generation.");
-        desc(                      "-crt <path>",          "Specify path to C runtime used for project generation.\n");
-        desc("CETEST", "no",       "-no-cetest",           "Do not compile Windows CE remote test application.");
-        desc("CETEST", "yes",      "-cetest",              "Compile Windows CE remote test application.\n");
-        desc(                      "-signature <file>",    "Use <file> for signing the target project.");
         return true;
     }
     return false;
@@ -2280,8 +2179,6 @@ bool Configure::checkAvailability(const QString &part)
         available = findFile("sqlite.h") && findFile("sqlite.lib");
     else if (part == "SQL_IBASE")
         available = findFile("ibase.h") && (findFile("gds32_ms.lib") || findFile("gds32.lib"));
-    else if (part == "OPENGL_ES_2")
-        available = (dictionary.value("XQMAKESPEC").startsWith("wince"));
     else if (part == "SSE2")
         available = tryCompileProject("common/sse2");
     else if (part == "SSE3")
@@ -2302,20 +2199,7 @@ bool Configure::checkAvailability(const QString &part)
         available = dictionary.contains("XQMAKESPEC") && tryCompileProject("common/libproxy");
     else if (part == "DBUS")
         available = findFile("dbus\\dbus.h");
-    else if (part == "CETEST") {
-        const QString rapiHeader = QDir::toNativeSeparators(locateFile("rapi.h"));
-        const QString rapiLib = QDir::toNativeSeparators(locateFile("rapi.lib"));
-        available = (dictionary.value("XQMAKESPEC").startsWith("wince")) && !rapiHeader.isEmpty() && !rapiLib.isEmpty();
-        if (available) {
-            dictionary[ "QT_CE_RAPI_INC" ] += QLatin1String("\"") + rapiHeader + QLatin1String("\"");
-            dictionary[ "QT_CE_RAPI_LIB" ] += QLatin1String("\"") + rapiLib + QLatin1String("\"");
-        }
-        else if (dictionary[ "CETEST_REQUESTED" ] == "yes") {
-            cout << "cetest could not be enabled: rapi.h and rapi.lib could not be found." << endl;
-            cout << "Make sure the environment is set up for compiling with ActiveSync." << endl;
-            dictionary[ "DONE" ] = "error";
-        }
-    } else if (part == "INCREDIBUILD_XGE") {
+    else if (part == "INCREDIBUILD_XGE") {
         available = !QStandardPaths::findExecutable(QStringLiteral("BuildConsole.exe")).isEmpty()
                     && !QStandardPaths::findExecutable(QStringLiteral("xgConsole.exe")).isEmpty();
     } else if (part == "WMSDK") {
@@ -2341,7 +2225,7 @@ bool Configure::checkAvailability(const QString &part)
     } else if (part == "QT_EVENTFD") {
         available = tryCompileProject("unix/eventfd");
     } else if (part == "CUPS") {
-        available = (platform() != WINDOWS) && (platform() != WINDOWS_CE) && (platform() != WINDOWS_RT) && tryCompileProject("unix/cups");
+        available = (platform() != WINDOWS) && (platform() != WINDOWS_RT) && tryCompileProject("unix/cups");
     } else if (part == "STACK_PROTECTOR_STRONG") {
         available = (platform() == QNX) && compilerSupportsFlag("qcc -fstack-protector-strong");
     } else if (part == "SLOG2") {
@@ -2503,10 +2387,6 @@ void Configure::autoDetection()
     if (dictionary["WMSDK"] == "auto")
         dictionary["WMSDK"] = checkAvailability("WMSDK") ? "yes" : "no";
 
-    // Qt/WinCE remote test application
-    if (dictionary["CETEST"] == "auto")
-        dictionary["CETEST"] = checkAvailability("CETEST") ? "yes" : "no";
-
     // Detection of IncrediBuild buildconsole
     if (dictionary["INCREDIBUILD_XGE"] == "auto")
         dictionary["INCREDIBUILD_XGE"] = checkAvailability("INCREDIBUILD_XGE") ? "yes" : "no";
@@ -2837,12 +2717,6 @@ void Configure::generateOutputVars()
     if (dictionary[ "STYLE_WINDOWSVISTA" ] == "yes")
         qmakeStyles += "windowsvista";
 
-    if (dictionary[ "STYLE_WINDOWSCE" ] == "yes")
-    qmakeStyles += "windowsce";
-
-    if (dictionary[ "STYLE_WINDOWSMOBILE" ] == "yes")
-    qmakeStyles += "windowsmobile";
-
     if (dictionary[ "STYLE_ANDROID" ] == "yes")
         qmakeStyles += "android";
 
@@ -2966,9 +2840,6 @@ void Configure::generateOutputVars()
     else if (dictionary[ "DBUS" ] == "linked")
         qtConfig += "dbus dbus-linked";
 
-    if (dictionary[ "CETEST" ] == "yes")
-        qtConfig += "cetest";
-
     // ### Vestige
     if (dictionary["AUDIO_BACKEND"] == "yes")
         qtConfig += "audio-backend";
@@ -3159,17 +3030,6 @@ void Configure::generateCachefile()
         if (dictionary["QT_XKBCOMMON"] == "no")
             moduleStream << "DEFINES += QT_NO_XKBCOMMON" << endl;
 
-        if (dictionary["CETEST"] == "yes") {
-            moduleStream << "QT_CE_RAPI_INC  = " << formatPath(dictionary["QT_CE_RAPI_INC"]) << endl;
-            moduleStream << "QT_CE_RAPI_LIB  = " << formatPath(dictionary["QT_CE_RAPI_LIB"]) << endl;
-        }
-
-        moduleStream << "#Qt for Windows CE c-runtime deployment" << endl
-                     << "QT_CE_C_RUNTIME = " << formatPath(dictionary["CE_CRT"]) << endl;
-
-        if (dictionary["CE_SIGNATURE"] != QLatin1String("no"))
-            moduleStream << "DEFAULT_SIGNATURE=" << dictionary["CE_SIGNATURE"] << endl;
-
         // embedded
         if (!dictionary["KBD_DRIVERS"].isEmpty())
             moduleStream << "kbd-drivers += "<< dictionary["KBD_DRIVERS"]<<endl;
@@ -3453,7 +3313,9 @@ void Configure::generateQDevicePri()
         deviceStream << "android_install {" << endl;
         deviceStream << "    DEFAULT_ANDROID_SDK_ROOT = " << formatPath(dictionary["ANDROID_SDK_ROOT"]) << endl;
         deviceStream << "    DEFAULT_ANDROID_NDK_ROOT = " << formatPath(dictionary["ANDROID_NDK_ROOT"]) << endl;
-        if (QSysInfo::WordSize == 64)
+        if (dictionary.contains("ANDROID_HOST"))
+            deviceStream << "    DEFAULT_ANDROID_NDK_HOST = " << dictionary["ANDROID_HOST"] << endl;
+        else if (QSysInfo::WordSize == 64)
             deviceStream << "    DEFAULT_ANDROID_NDK_HOST = windows-x86_64" << endl;
         else
             deviceStream << "    DEFAULT_ANDROID_NDK_HOST = windows" << endl;
@@ -3528,7 +3390,7 @@ void Configure::generateQConfigPri()
         configStream << "    QT_TARGET_ARCH = " << dictionary["QT_ARCH"] << endl;
         configStream << "} else {" << endl;
         configStream << "    QT_ARCH = " << dictionary["QT_ARCH"] << endl;
-        if (dictionary.contains("XQMAKESPEC") && !dictionary["XQMAKESPEC"].startsWith("wince")) {
+        if (dictionary.contains("XQMAKESPEC")) {
             // FIXME: add detection
             configStream << "    QMAKE_DEFAULT_LIBDIRS = /lib /usr/lib" << endl;
             configStream << "    QMAKE_DEFAULT_INCDIRS = /usr/include /usr/local/include" << endl;
@@ -3692,8 +3554,6 @@ void Configure::generateConfigfiles()
         if (dictionary["STYLE_WINDOWSXP"] != "yes" && dictionary["STYLE_WINDOWSVISTA"] != "yes")
             qconfigList += "QT_NO_STYLE_WINDOWSXP";
         if (dictionary["STYLE_WINDOWSVISTA"] != "yes")   qconfigList += "QT_NO_STYLE_WINDOWSVISTA";
-        if (dictionary["STYLE_WINDOWSCE"] != "yes")   qconfigList += "QT_NO_STYLE_WINDOWSCE";
-        if (dictionary["STYLE_WINDOWSMOBILE"] != "yes")   qconfigList += "QT_NO_STYLE_WINDOWSMOBILE";
 
         if (dictionary["GIF"] == "yes")              qconfigList += "QT_BUILTIN_GIF_READER=1";
         if (dictionary["PNG"] != "yes")              qconfigList += "QT_NO_IMAGEFORMAT_PNG";
@@ -3726,8 +3586,7 @@ void Configure::generateConfigfiles()
 
         if (dictionary["POSIX_IPC"] == "yes")
             qconfigList += "QT_POSIX_IPC";
-        else if ((platform() != ANDROID) && (platform() != WINDOWS) && (platform() != WINDOWS_CE)
-                    && (platform() != WINDOWS_RT))
+        else if ((platform() != ANDROID) && (platform() != WINDOWS) && (platform() != WINDOWS_RT))
             qconfigList << "QT_NO_SYSTEMSEMAPHORE" << "QT_NO_SHAREDMEMORY";
 
         if (dictionary["FONT_CONFIG"] == "no")       qconfigList += "QT_NO_FONTCONFIG";
@@ -3904,8 +3763,6 @@ void Configure::displayConfig()
     sout << "    Windows XP.............." << dictionary[ "STYLE_WINDOWSXP" ] << endl;
     sout << "    Windows Vista..........." << dictionary[ "STYLE_WINDOWSVISTA" ] << endl;
     sout << "    Fusion.................." << dictionary[ "STYLE_FUSION" ] << endl;
-    sout << "    Windows CE.............." << dictionary[ "STYLE_WINDOWSCE" ] << endl;
-    sout << "    Windows Mobile.........." << dictionary[ "STYLE_WINDOWSMOBILE" ] << endl;
     sout << endl;
 
     sout << "Sql Drivers:" << endl;
@@ -3937,13 +3794,6 @@ void Configure::displayConfig()
     sout << "Examples installed to......." << formatConfigPath("QT_REL_INSTALL_EXAMPLES") << endl;
     sout << "Tests installed to.........." << formatConfigPath("QT_REL_INSTALL_TESTS") << endl;
 
-    if (dictionary.contains("XQMAKESPEC") && dictionary["XQMAKESPEC"].startsWith(QLatin1String("wince"))) {
-        sout << "Using c runtime detection..." << dictionary[ "CE_CRT" ] << endl;
-        sout << "Cetest support.............." << dictionary[ "CETEST" ] << endl;
-        sout << "Signature..................." << dictionary[ "CE_SIGNATURE"] << endl;
-        sout << endl;
-    }
-
     if (checkAvailability("INCREDIBUILD_XGE"))
         sout << "Using IncrediBuild XGE......" << dictionary["INCREDIBUILD_XGE"] << endl;
     if (!qmakeDefines.isEmpty()) {
@@ -4236,7 +4086,7 @@ void Configure::generateQConfigCpp()
                   << confStrings[1] << "#endif\n"
                   << ";\n"
                   << endl;
-        if ((platform() != WINDOWS) && (platform() != WINDOWS_CE) && (platform() != WINDOWS_RT))
+        if ((platform() != WINDOWS) && (platform() != WINDOWS_RT))
             tmpStream << "#define QT_CONFIGURE_SETTINGS_PATH \"" << dictionary["QT_REL_INSTALL_SETTINGS"] << "\"" << endl;
 
         tmpStream << endl
@@ -4477,7 +4327,6 @@ bool Configure::showLicense(QString orgLicenseFile)
     QString theLicense;
     if (dictionary["EDITION"] == "OpenSource") {
         if (platform() != WINDOWS_RT
-                && platform() != WINDOWS_CE
                 && (platform() != ANDROID || dictionary["ANDROID_STYLE_ASSETS"] == "no")) {
             theLicense = "GNU Lesser General Public License (LGPL) version 3\n"
                          "or the GNU General Public License (GPL) version 2";
@@ -4644,8 +4493,6 @@ QString Configure::platformName() const
     default:
     case WINDOWS:
         return QStringLiteral("Qt for Windows");
-    case WINDOWS_CE:
-        return QStringLiteral("Qt for Windows CE");
     case WINDOWS_RT:
         return QStringLiteral("Qt for Windows Runtime");
     case QNX:
@@ -4662,7 +4509,6 @@ QString Configure::qpaPlatformName() const
     switch (platform()) {
     default:
     case WINDOWS:
-    case WINDOWS_CE:
         return QStringLiteral("windows");
     case WINDOWS_RT:
         return QStringLiteral("winrt");
@@ -4683,9 +4529,6 @@ int Configure::platform() const
     if ((xQMakeSpec.startsWith("winphone") || xQMakeSpec.startsWith("winrt")))
         return WINDOWS_RT;
 
-    if ((qMakeSpec.startsWith("wince") || xQMakeSpec.startsWith("wince")))
-        return WINDOWS_CE;
-
     if (xQMakeSpec.contains("qnx"))
         return QNX;